1249423Sdim//===--- ASTReader.cpp - AST File Reader ----------------------------------===// 2212795Sdim// 3212795Sdim// The LLVM Compiler Infrastructure 4212795Sdim// 5212795Sdim// This file is distributed under the University of Illinois Open Source 6212795Sdim// License. See LICENSE.TXT for details. 7212795Sdim// 8212795Sdim//===----------------------------------------------------------------------===// 9212795Sdim// 10212795Sdim// This file defines the ASTReader class, which reads AST files. 11212795Sdim// 12212795Sdim//===----------------------------------------------------------------------===// 13212795Sdim 14212795Sdim#include "clang/Serialization/ASTReader.h" 15212795Sdim#include "ASTCommon.h" 16226633Sdim#include "ASTReaderInternals.h" 17212795Sdim#include "clang/AST/ASTConsumer.h" 18212795Sdim#include "clang/AST/ASTContext.h" 19212795Sdim#include "clang/AST/DeclTemplate.h" 20212795Sdim#include "clang/AST/Expr.h" 21212795Sdim#include "clang/AST/ExprCXX.h" 22221345Sdim#include "clang/AST/NestedNameSpecifier.h" 23212795Sdim#include "clang/AST/Type.h" 24212795Sdim#include "clang/AST/TypeLocVisitor.h" 25249423Sdim#include "clang/Basic/FileManager.h" 26212795Sdim#include "clang/Basic/SourceManager.h" 27212795Sdim#include "clang/Basic/SourceManagerInternals.h" 28212795Sdim#include "clang/Basic/TargetInfo.h" 29243830Sdim#include "clang/Basic/TargetOptions.h" 30212795Sdim#include "clang/Basic/Version.h" 31221345Sdim#include "clang/Basic/VersionTuple.h" 32249423Sdim#include "clang/Lex/HeaderSearch.h" 33249423Sdim#include "clang/Lex/HeaderSearchOptions.h" 34249423Sdim#include "clang/Lex/MacroInfo.h" 35249423Sdim#include "clang/Lex/PreprocessingRecord.h" 36249423Sdim#include "clang/Lex/Preprocessor.h" 37249423Sdim#include "clang/Lex/PreprocessorOptions.h" 38249423Sdim#include "clang/Sema/Scope.h" 39249423Sdim#include "clang/Sema/Sema.h" 40249423Sdim#include "clang/Serialization/ASTDeserializationListener.h" 41249423Sdim#include "clang/Serialization/GlobalModuleIndex.h" 42249423Sdim#include "clang/Serialization/ModuleManager.h" 43249423Sdim#include "clang/Serialization/SerializationDiagnostic.h" 44249423Sdim#include "llvm/ADT/Hashing.h" 45212795Sdim#include "llvm/ADT/StringExtras.h" 46212795Sdim#include "llvm/Bitcode/BitstreamReader.h" 47212795Sdim#include "llvm/Support/ErrorHandling.h" 48218893Sdim#include "llvm/Support/FileSystem.h" 49249423Sdim#include "llvm/Support/MemoryBuffer.h" 50218893Sdim#include "llvm/Support/Path.h" 51234982Sdim#include "llvm/Support/SaveAndRestore.h" 52218893Sdim#include "llvm/Support/system_error.h" 53212795Sdim#include <algorithm> 54249423Sdim#include <cstdio> 55212795Sdim#include <iterator> 56218893Sdim 57212795Sdimusing namespace clang; 58212795Sdimusing namespace clang::serialization; 59226633Sdimusing namespace clang::serialization::reader; 60249423Sdimusing llvm::BitstreamCursor; 61212795Sdim 62212795Sdim//===----------------------------------------------------------------------===// 63212795Sdim// PCH validator implementation 64212795Sdim//===----------------------------------------------------------------------===// 65212795Sdim 66212795SdimASTReaderListener::~ASTReaderListener() {} 67212795Sdim 68243830Sdim/// \brief Compare the given set of language options against an existing set of 69243830Sdim/// language options. 70243830Sdim/// 71243830Sdim/// \param Diags If non-NULL, diagnostics will be emitted via this engine. 72243830Sdim/// 73243830Sdim/// \returns true if the languagae options mis-match, false otherwise. 74243830Sdimstatic bool checkLanguageOptions(const LangOptions &LangOpts, 75243830Sdim const LangOptions &ExistingLangOpts, 76243830Sdim DiagnosticsEngine *Diags) { 77243830Sdim#define LANGOPT(Name, Bits, Default, Description) \ 78243830Sdim if (ExistingLangOpts.Name != LangOpts.Name) { \ 79243830Sdim if (Diags) \ 80243830Sdim Diags->Report(diag::err_pch_langopt_mismatch) \ 81243830Sdim << Description << LangOpts.Name << ExistingLangOpts.Name; \ 82243830Sdim return true; \ 83243830Sdim } 84243830Sdim 85243830Sdim#define VALUE_LANGOPT(Name, Bits, Default, Description) \ 86243830Sdim if (ExistingLangOpts.Name != LangOpts.Name) { \ 87243830Sdim if (Diags) \ 88243830Sdim Diags->Report(diag::err_pch_langopt_value_mismatch) \ 89243830Sdim << Description; \ 90226633Sdim return true; \ 91212795Sdim } 92212795Sdim 93243830Sdim#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 94243830Sdim if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \ 95243830Sdim if (Diags) \ 96243830Sdim Diags->Report(diag::err_pch_langopt_value_mismatch) \ 97243830Sdim << Description; \ 98243830Sdim return true; \ 99212795Sdim } 100212795Sdim 101226633Sdim#define BENIGN_LANGOPT(Name, Bits, Default, Description) 102226633Sdim#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) 103226633Sdim#include "clang/Basic/LangOptions.def" 104239462Sdim 105243830Sdim if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) { 106243830Sdim if (Diags) 107243830Sdim Diags->Report(diag::err_pch_langopt_value_mismatch) 108239462Sdim << "target Objective-C runtime"; 109239462Sdim return true; 110239462Sdim } 111243830Sdim 112249423Sdim if (ExistingLangOpts.CommentOpts.BlockCommandNames != 113249423Sdim LangOpts.CommentOpts.BlockCommandNames) { 114249423Sdim if (Diags) 115249423Sdim Diags->Report(diag::err_pch_langopt_value_mismatch) 116249423Sdim << "block command names"; 117249423Sdim return true; 118249423Sdim } 119249423Sdim 120212795Sdim return false; 121212795Sdim} 122212795Sdim 123243830Sdim/// \brief Compare the given set of target options against an existing set of 124243830Sdim/// target options. 125243830Sdim/// 126243830Sdim/// \param Diags If non-NULL, diagnostics will be emitted via this engine. 127243830Sdim/// 128243830Sdim/// \returns true if the target options mis-match, false otherwise. 129243830Sdimstatic bool checkTargetOptions(const TargetOptions &TargetOpts, 130243830Sdim const TargetOptions &ExistingTargetOpts, 131243830Sdim DiagnosticsEngine *Diags) { 132243830Sdim#define CHECK_TARGET_OPT(Field, Name) \ 133243830Sdim if (TargetOpts.Field != ExistingTargetOpts.Field) { \ 134243830Sdim if (Diags) \ 135243830Sdim Diags->Report(diag::err_pch_targetopt_mismatch) \ 136243830Sdim << Name << TargetOpts.Field << ExistingTargetOpts.Field; \ 137243830Sdim return true; \ 138243830Sdim } 139212795Sdim 140243830Sdim CHECK_TARGET_OPT(Triple, "target"); 141243830Sdim CHECK_TARGET_OPT(CPU, "target CPU"); 142243830Sdim CHECK_TARGET_OPT(ABI, "target ABI"); 143243830Sdim CHECK_TARGET_OPT(CXXABI, "target C++ ABI"); 144243830Sdim CHECK_TARGET_OPT(LinkerVersion, "target linker version"); 145243830Sdim#undef CHECK_TARGET_OPT 146212795Sdim 147243830Sdim // Compare feature sets. 148243830Sdim SmallVector<StringRef, 4> ExistingFeatures( 149243830Sdim ExistingTargetOpts.FeaturesAsWritten.begin(), 150243830Sdim ExistingTargetOpts.FeaturesAsWritten.end()); 151243830Sdim SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(), 152243830Sdim TargetOpts.FeaturesAsWritten.end()); 153243830Sdim std::sort(ExistingFeatures.begin(), ExistingFeatures.end()); 154243830Sdim std::sort(ReadFeatures.begin(), ReadFeatures.end()); 155212795Sdim 156243830Sdim unsigned ExistingIdx = 0, ExistingN = ExistingFeatures.size(); 157243830Sdim unsigned ReadIdx = 0, ReadN = ReadFeatures.size(); 158243830Sdim while (ExistingIdx < ExistingN && ReadIdx < ReadN) { 159243830Sdim if (ExistingFeatures[ExistingIdx] == ReadFeatures[ReadIdx]) { 160243830Sdim ++ExistingIdx; 161243830Sdim ++ReadIdx; 162243830Sdim continue; 163243830Sdim } 164212795Sdim 165243830Sdim if (ReadFeatures[ReadIdx] < ExistingFeatures[ExistingIdx]) { 166243830Sdim if (Diags) 167243830Sdim Diags->Report(diag::err_pch_targetopt_feature_mismatch) 168243830Sdim << false << ReadFeatures[ReadIdx]; 169243830Sdim return true; 170243830Sdim } 171212795Sdim 172243830Sdim if (Diags) 173243830Sdim Diags->Report(diag::err_pch_targetopt_feature_mismatch) 174243830Sdim << true << ExistingFeatures[ExistingIdx]; 175243830Sdim return true; 176212795Sdim } 177212795Sdim 178243830Sdim if (ExistingIdx < ExistingN) { 179243830Sdim if (Diags) 180243830Sdim Diags->Report(diag::err_pch_targetopt_feature_mismatch) 181243830Sdim << true << ExistingFeatures[ExistingIdx]; 182243830Sdim return true; 183212795Sdim } 184212795Sdim 185243830Sdim if (ReadIdx < ReadN) { 186243830Sdim if (Diags) 187243830Sdim Diags->Report(diag::err_pch_targetopt_feature_mismatch) 188243830Sdim << false << ReadFeatures[ReadIdx]; 189212795Sdim return true; 190212795Sdim } 191212795Sdim 192243830Sdim return false; 193243830Sdim} 194212795Sdim 195243830Sdimbool 196243830SdimPCHValidator::ReadLanguageOptions(const LangOptions &LangOpts, 197243830Sdim bool Complain) { 198243830Sdim const LangOptions &ExistingLangOpts = PP.getLangOpts(); 199243830Sdim return checkLanguageOptions(LangOpts, ExistingLangOpts, 200243830Sdim Complain? &Reader.Diags : 0); 201243830Sdim} 202212795Sdim 203243830Sdimbool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts, 204243830Sdim bool Complain) { 205243830Sdim const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts(); 206243830Sdim return checkTargetOptions(TargetOpts, ExistingTargetOpts, 207243830Sdim Complain? &Reader.Diags : 0); 208243830Sdim} 209212795Sdim 210243830Sdimnamespace { 211243830Sdim typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> > 212243830Sdim MacroDefinitionsMap; 213263508Sdim typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> > 214263508Sdim DeclsMap; 215243830Sdim} 216212795Sdim 217243830Sdim/// \brief Collect the macro definitions provided by the given preprocessor 218243830Sdim/// options. 219243830Sdimstatic void collectMacroDefinitions(const PreprocessorOptions &PPOpts, 220243830Sdim MacroDefinitionsMap &Macros, 221243830Sdim SmallVectorImpl<StringRef> *MacroNames = 0){ 222243830Sdim for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) { 223243830Sdim StringRef Macro = PPOpts.Macros[I].first; 224243830Sdim bool IsUndef = PPOpts.Macros[I].second; 225218893Sdim 226243830Sdim std::pair<StringRef, StringRef> MacroPair = Macro.split('='); 227243830Sdim StringRef MacroName = MacroPair.first; 228243830Sdim StringRef MacroBody = MacroPair.second; 229218893Sdim 230243830Sdim // For an #undef'd macro, we only care about the name. 231243830Sdim if (IsUndef) { 232243830Sdim if (MacroNames && !Macros.count(MacroName)) 233243830Sdim MacroNames->push_back(MacroName); 234218893Sdim 235243830Sdim Macros[MacroName] = std::make_pair("", true); 236218893Sdim continue; 237218893Sdim } 238243830Sdim 239243830Sdim // For a #define'd macro, figure out the actual definition. 240243830Sdim if (MacroName.size() == Macro.size()) 241243830Sdim MacroBody = "1"; 242243830Sdim else { 243243830Sdim // Note: GCC drops anything following an end-of-line character. 244243830Sdim StringRef::size_type End = MacroBody.find_first_of("\n\r"); 245243830Sdim MacroBody = MacroBody.substr(0, End); 246212795Sdim } 247212795Sdim 248243830Sdim if (MacroNames && !Macros.count(MacroName)) 249243830Sdim MacroNames->push_back(MacroName); 250243830Sdim Macros[MacroName] = std::make_pair(MacroBody, false); 251243830Sdim } 252243830Sdim} 253243830Sdim 254243830Sdim/// \brief Check the preprocessor options deserialized from the control block 255243830Sdim/// against the preprocessor options in an existing preprocessor. 256243830Sdim/// 257243830Sdim/// \param Diags If non-null, produce diagnostics for any mismatches incurred. 258243830Sdimstatic bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts, 259243830Sdim const PreprocessorOptions &ExistingPPOpts, 260243830Sdim DiagnosticsEngine *Diags, 261243830Sdim FileManager &FileMgr, 262251662Sdim std::string &SuggestedPredefines, 263251662Sdim const LangOptions &LangOpts) { 264243830Sdim // Check macro definitions. 265243830Sdim MacroDefinitionsMap ASTFileMacros; 266243830Sdim collectMacroDefinitions(PPOpts, ASTFileMacros); 267243830Sdim MacroDefinitionsMap ExistingMacros; 268243830Sdim SmallVector<StringRef, 4> ExistingMacroNames; 269243830Sdim collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames); 270212795Sdim 271243830Sdim for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) { 272243830Sdim // Dig out the macro definition in the existing preprocessor options. 273243830Sdim StringRef MacroName = ExistingMacroNames[I]; 274243830Sdim std::pair<StringRef, bool> Existing = ExistingMacros[MacroName]; 275212795Sdim 276243830Sdim // Check whether we know anything about this macro name or not. 277243830Sdim llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known 278243830Sdim = ASTFileMacros.find(MacroName); 279243830Sdim if (Known == ASTFileMacros.end()) { 280243830Sdim // FIXME: Check whether this identifier was referenced anywhere in the 281243830Sdim // AST file. If so, we should reject the AST file. Unfortunately, this 282243830Sdim // information isn't in the control block. What shall we do about it? 283212795Sdim 284243830Sdim if (Existing.second) { 285243830Sdim SuggestedPredefines += "#undef "; 286243830Sdim SuggestedPredefines += MacroName.str(); 287243830Sdim SuggestedPredefines += '\n'; 288243830Sdim } else { 289243830Sdim SuggestedPredefines += "#define "; 290243830Sdim SuggestedPredefines += MacroName.str(); 291243830Sdim SuggestedPredefines += ' '; 292243830Sdim SuggestedPredefines += Existing.first.str(); 293243830Sdim SuggestedPredefines += '\n'; 294243830Sdim } 295243830Sdim continue; 296212795Sdim } 297212795Sdim 298243830Sdim // If the macro was defined in one but undef'd in the other, we have a 299243830Sdim // conflict. 300243830Sdim if (Existing.second != Known->second.second) { 301243830Sdim if (Diags) { 302243830Sdim Diags->Report(diag::err_pch_macro_def_undef) 303243830Sdim << MacroName << Known->second.second; 304243830Sdim } 305243830Sdim return true; 306243830Sdim } 307212795Sdim 308243830Sdim // If the macro was #undef'd in both, or if the macro bodies are identical, 309243830Sdim // it's fine. 310243830Sdim if (Existing.second || Existing.first == Known->second.first) 311212795Sdim continue; 312212795Sdim 313243830Sdim // The macro bodies differ; complain. 314243830Sdim if (Diags) { 315243830Sdim Diags->Report(diag::err_pch_macro_def_conflict) 316243830Sdim << MacroName << Known->second.first << Existing.first; 317212795Sdim } 318243830Sdim return true; 319212795Sdim } 320212795Sdim 321243830Sdim // Check whether we're using predefines. 322243830Sdim if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) { 323243830Sdim if (Diags) { 324243830Sdim Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines; 325243830Sdim } 326212795Sdim return true; 327243830Sdim } 328212795Sdim 329251662Sdim // Detailed record is important since it is used for the module cache hash. 330251662Sdim if (LangOpts.Modules && 331251662Sdim PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord) { 332251662Sdim if (Diags) { 333251662Sdim Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord; 334251662Sdim } 335251662Sdim return true; 336251662Sdim } 337251662Sdim 338243830Sdim // Compute the #include and #include_macros lines we need. 339243830Sdim for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) { 340243830Sdim StringRef File = ExistingPPOpts.Includes[I]; 341243830Sdim if (File == ExistingPPOpts.ImplicitPCHInclude) 342243830Sdim continue; 343212795Sdim 344243830Sdim if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File) 345243830Sdim != PPOpts.Includes.end()) 346243830Sdim continue; 347212795Sdim 348243830Sdim SuggestedPredefines += "#include \""; 349243830Sdim SuggestedPredefines += 350243830Sdim HeaderSearch::NormalizeDashIncludePath(File, FileMgr); 351243830Sdim SuggestedPredefines += "\"\n"; 352243830Sdim } 353212795Sdim 354243830Sdim for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) { 355243830Sdim StringRef File = ExistingPPOpts.MacroIncludes[I]; 356243830Sdim if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(), 357243830Sdim File) 358243830Sdim != PPOpts.MacroIncludes.end()) 359243830Sdim continue; 360243830Sdim 361243830Sdim SuggestedPredefines += "#__include_macros \""; 362243830Sdim SuggestedPredefines += 363243830Sdim HeaderSearch::NormalizeDashIncludePath(File, FileMgr); 364243830Sdim SuggestedPredefines += "\"\n##\n"; 365212795Sdim } 366212795Sdim 367212795Sdim return false; 368212795Sdim} 369212795Sdim 370243830Sdimbool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 371243830Sdim bool Complain, 372243830Sdim std::string &SuggestedPredefines) { 373243830Sdim const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts(); 374243830Sdim 375243830Sdim return checkPreprocessorOptions(PPOpts, ExistingPPOpts, 376243830Sdim Complain? &Reader.Diags : 0, 377243830Sdim PP.getFileManager(), 378251662Sdim SuggestedPredefines, 379251662Sdim PP.getLangOpts()); 380243830Sdim} 381243830Sdim 382243830Sdimvoid PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) { 383212795Sdim PP.setCounterValue(Value); 384212795Sdim} 385212795Sdim 386212795Sdim//===----------------------------------------------------------------------===// 387212795Sdim// AST reader implementation 388212795Sdim//===----------------------------------------------------------------------===// 389212795Sdim 390212795Sdimvoid 391212795SdimASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 392212795Sdim DeserializationListener = Listener; 393212795Sdim} 394212795Sdim 395212795Sdim 396212795Sdim 397226633Sdimunsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) { 398226633Sdim return serialization::ComputeHash(Sel); 399226633Sdim} 400212795Sdim 401212795Sdim 402226633Sdimstd::pair<unsigned, unsigned> 403226633SdimASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 404226633Sdim using namespace clang::io; 405226633Sdim unsigned KeyLen = ReadUnalignedLE16(d); 406226633Sdim unsigned DataLen = ReadUnalignedLE16(d); 407226633Sdim return std::make_pair(KeyLen, DataLen); 408226633Sdim} 409212795Sdim 410226633SdimASTSelectorLookupTrait::internal_key_type 411226633SdimASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) { 412226633Sdim using namespace clang::io; 413226633Sdim SelectorTable &SelTable = Reader.getContext().Selectors; 414226633Sdim unsigned N = ReadUnalignedLE16(d); 415226633Sdim IdentifierInfo *FirstII 416226633Sdim = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 417226633Sdim if (N == 0) 418226633Sdim return SelTable.getNullarySelector(FirstII); 419226633Sdim else if (N == 1) 420226633Sdim return SelTable.getUnarySelector(FirstII); 421212795Sdim 422226633Sdim SmallVector<IdentifierInfo *, 16> Args; 423226633Sdim Args.push_back(FirstII); 424226633Sdim for (unsigned I = 1; I != N; ++I) 425226633Sdim Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d))); 426212795Sdim 427226633Sdim return SelTable.getSelector(N, Args.data()); 428226633Sdim} 429212795Sdim 430226633SdimASTSelectorLookupTrait::data_type 431226633SdimASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d, 432226633Sdim unsigned DataLen) { 433226633Sdim using namespace clang::io; 434212795Sdim 435226633Sdim data_type Result; 436212795Sdim 437226633Sdim Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d)); 438251662Sdim unsigned NumInstanceMethodsAndBits = ReadUnalignedLE16(d); 439251662Sdim unsigned NumFactoryMethodsAndBits = ReadUnalignedLE16(d); 440251662Sdim Result.InstanceBits = NumInstanceMethodsAndBits & 0x3; 441251662Sdim Result.FactoryBits = NumFactoryMethodsAndBits & 0x3; 442251662Sdim unsigned NumInstanceMethods = NumInstanceMethodsAndBits >> 2; 443251662Sdim unsigned NumFactoryMethods = NumFactoryMethodsAndBits >> 2; 444212795Sdim 445226633Sdim // Load instance methods 446226633Sdim for (unsigned I = 0; I != NumInstanceMethods; ++I) { 447226633Sdim if (ObjCMethodDecl *Method 448226633Sdim = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d))) 449226633Sdim Result.Instance.push_back(Method); 450212795Sdim } 451212795Sdim 452226633Sdim // Load factory methods 453226633Sdim for (unsigned I = 0; I != NumFactoryMethods; ++I) { 454226633Sdim if (ObjCMethodDecl *Method 455226633Sdim = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d))) 456226633Sdim Result.Factory.push_back(Method); 457212795Sdim } 458212795Sdim 459226633Sdim return Result; 460226633Sdim} 461212795Sdim 462249423Sdimunsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) { 463249423Sdim return llvm::HashString(a); 464226633Sdim} 465212795Sdim 466226633Sdimstd::pair<unsigned, unsigned> 467249423SdimASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) { 468226633Sdim using namespace clang::io; 469226633Sdim unsigned DataLen = ReadUnalignedLE16(d); 470226633Sdim unsigned KeyLen = ReadUnalignedLE16(d); 471226633Sdim return std::make_pair(KeyLen, DataLen); 472226633Sdim} 473212795Sdim 474249423SdimASTIdentifierLookupTraitBase::internal_key_type 475249423SdimASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) { 476226633Sdim assert(n >= 2 && d[n-1] == '\0'); 477249423Sdim return StringRef((const char*) d, n-1); 478226633Sdim} 479212795Sdim 480249423Sdim/// \brief Whether the given identifier is "interesting". 481249423Sdimstatic bool isInterestingIdentifier(IdentifierInfo &II) { 482249423Sdim return II.isPoisoned() || 483249423Sdim II.isExtensionToken() || 484249423Sdim II.getObjCOrBuiltinID() || 485249423Sdim II.hasRevertedTokenIDToIdentifier() || 486249423Sdim II.hadMacroDefinition() || 487249423Sdim II.getFETokenInfo<void>(); 488249423Sdim} 489249423Sdim 490226633SdimIdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k, 491226633Sdim const unsigned char* d, 492226633Sdim unsigned DataLen) { 493226633Sdim using namespace clang::io; 494226633Sdim unsigned RawID = ReadUnalignedLE32(d); 495226633Sdim bool IsInteresting = RawID & 0x01; 496212795Sdim 497226633Sdim // Wipe out the "is interesting" bit. 498226633Sdim RawID = RawID >> 1; 499212795Sdim 500226633Sdim IdentID ID = Reader.getGlobalIdentifierID(F, RawID); 501226633Sdim if (!IsInteresting) { 502226633Sdim // For uninteresting identifiers, just build the IdentifierInfo 503226633Sdim // and associate it with the persistent ID. 504212795Sdim IdentifierInfo *II = KnownII; 505234353Sdim if (!II) { 506249423Sdim II = &Reader.getIdentifierTable().getOwn(k); 507234353Sdim KnownII = II; 508234353Sdim } 509212795Sdim Reader.SetIdentifierInfo(ID, II); 510249423Sdim if (!II->isFromAST()) { 511249423Sdim bool WasInteresting = isInterestingIdentifier(*II); 512249423Sdim II->setIsFromAST(); 513249423Sdim if (WasInteresting) 514249423Sdim II->setChangedSinceDeserialization(); 515249423Sdim } 516249423Sdim Reader.markIdentifierUpToDate(II); 517212795Sdim return II; 518212795Sdim } 519212795Sdim 520243830Sdim unsigned ObjCOrBuiltinID = ReadUnalignedLE16(d); 521226633Sdim unsigned Bits = ReadUnalignedLE16(d); 522226633Sdim bool CPlusPlusOperatorKeyword = Bits & 0x01; 523226633Sdim Bits >>= 1; 524226633Sdim bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 525226633Sdim Bits >>= 1; 526226633Sdim bool Poisoned = Bits & 0x01; 527226633Sdim Bits >>= 1; 528226633Sdim bool ExtensionToken = Bits & 0x01; 529226633Sdim Bits >>= 1; 530249423Sdim bool hasSubmoduleMacros = Bits & 0x01; 531249423Sdim Bits >>= 1; 532243830Sdim bool hadMacroDefinition = Bits & 0x01; 533226633Sdim Bits >>= 1; 534212795Sdim 535226633Sdim assert(Bits == 0 && "Extra bits in the identifier?"); 536243830Sdim DataLen -= 8; 537212795Sdim 538226633Sdim // Build the IdentifierInfo itself and link the identifier ID with 539226633Sdim // the new IdentifierInfo. 540226633Sdim IdentifierInfo *II = KnownII; 541234353Sdim if (!II) { 542249423Sdim II = &Reader.getIdentifierTable().getOwn(StringRef(k)); 543234353Sdim KnownII = II; 544234353Sdim } 545234353Sdim Reader.markIdentifierUpToDate(II); 546249423Sdim if (!II->isFromAST()) { 547249423Sdim bool WasInteresting = isInterestingIdentifier(*II); 548249423Sdim II->setIsFromAST(); 549249423Sdim if (WasInteresting) 550249423Sdim II->setChangedSinceDeserialization(); 551249423Sdim } 552212795Sdim 553226633Sdim // Set or check the various bits in the IdentifierInfo structure. 554226633Sdim // Token IDs are read-only. 555249423Sdim if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier) 556226633Sdim II->RevertTokenIDToIdentifier(); 557226633Sdim II->setObjCOrBuiltinID(ObjCOrBuiltinID); 558226633Sdim assert(II->isExtensionToken() == ExtensionToken && 559226633Sdim "Incorrect extension token flag"); 560226633Sdim (void)ExtensionToken; 561226633Sdim if (Poisoned) 562226633Sdim II->setIsPoisoned(true); 563226633Sdim assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 564226633Sdim "Incorrect C++ operator keyword flag"); 565226633Sdim (void)CPlusPlusOperatorKeyword; 566212795Sdim 567226633Sdim // If this identifier is a macro, deserialize the macro 568226633Sdim // definition. 569243830Sdim if (hadMacroDefinition) { 570249423Sdim uint32_t MacroDirectivesOffset = ReadUnalignedLE32(d); 571249423Sdim DataLen -= 4; 572249423Sdim SmallVector<uint32_t, 8> LocalMacroIDs; 573249423Sdim if (hasSubmoduleMacros) { 574249423Sdim while (uint32_t LocalMacroID = ReadUnalignedLE32(d)) { 575249423Sdim DataLen -= 4; 576249423Sdim LocalMacroIDs.push_back(LocalMacroID); 577249423Sdim } 578243830Sdim DataLen -= 4; 579234353Sdim } 580249423Sdim 581249423Sdim if (F.Kind == MK_Module) { 582249423Sdim for (SmallVectorImpl<uint32_t>::iterator 583249423Sdim I = LocalMacroIDs.begin(), E = LocalMacroIDs.end(); I != E; ++I) { 584249423Sdim MacroID MacID = Reader.getGlobalMacroID(F, *I); 585249423Sdim Reader.addPendingMacroFromModule(II, &F, MacID, F.DirectImportLoc); 586249423Sdim } 587249423Sdim } else { 588249423Sdim Reader.addPendingMacroFromPCH(II, &F, MacroDirectivesOffset); 589249423Sdim } 590226633Sdim } 591212795Sdim 592234353Sdim Reader.SetIdentifierInfo(ID, II); 593234353Sdim 594226633Sdim // Read all of the declarations visible at global scope with this 595226633Sdim // name. 596226633Sdim if (DataLen > 0) { 597226633Sdim SmallVector<uint32_t, 4> DeclIDs; 598226633Sdim for (; DataLen > 0; DataLen -= 4) 599226633Sdim DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d))); 600226633Sdim Reader.SetGloballyVisibleDecls(II, DeclIDs); 601212795Sdim } 602212795Sdim 603226633Sdim return II; 604226633Sdim} 605212795Sdim 606226633Sdimunsigned 607226633SdimASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const { 608226633Sdim llvm::FoldingSetNodeID ID; 609226633Sdim ID.AddInteger(Key.Kind); 610212795Sdim 611226633Sdim switch (Key.Kind) { 612226633Sdim case DeclarationName::Identifier: 613226633Sdim case DeclarationName::CXXLiteralOperatorName: 614226633Sdim ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 615226633Sdim break; 616226633Sdim case DeclarationName::ObjCZeroArgSelector: 617226633Sdim case DeclarationName::ObjCOneArgSelector: 618226633Sdim case DeclarationName::ObjCMultiArgSelector: 619226633Sdim ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 620226633Sdim break; 621226633Sdim case DeclarationName::CXXOperatorName: 622226633Sdim ID.AddInteger((OverloadedOperatorKind)Key.Data); 623226633Sdim break; 624226633Sdim case DeclarationName::CXXConstructorName: 625226633Sdim case DeclarationName::CXXDestructorName: 626226633Sdim case DeclarationName::CXXConversionFunctionName: 627226633Sdim case DeclarationName::CXXUsingDirective: 628226633Sdim break; 629212795Sdim } 630212795Sdim 631226633Sdim return ID.ComputeHash(); 632226633Sdim} 633218893Sdim 634226633SdimASTDeclContextNameLookupTrait::internal_key_type 635226633SdimASTDeclContextNameLookupTrait::GetInternalKey( 636226633Sdim const external_key_type& Name) const { 637226633Sdim DeclNameKey Key; 638226633Sdim Key.Kind = Name.getNameKind(); 639226633Sdim switch (Name.getNameKind()) { 640226633Sdim case DeclarationName::Identifier: 641226633Sdim Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 642226633Sdim break; 643226633Sdim case DeclarationName::ObjCZeroArgSelector: 644226633Sdim case DeclarationName::ObjCOneArgSelector: 645226633Sdim case DeclarationName::ObjCMultiArgSelector: 646226633Sdim Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 647226633Sdim break; 648226633Sdim case DeclarationName::CXXOperatorName: 649226633Sdim Key.Data = Name.getCXXOverloadedOperator(); 650226633Sdim break; 651226633Sdim case DeclarationName::CXXLiteralOperatorName: 652226633Sdim Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 653226633Sdim break; 654226633Sdim case DeclarationName::CXXConstructorName: 655226633Sdim case DeclarationName::CXXDestructorName: 656226633Sdim case DeclarationName::CXXConversionFunctionName: 657226633Sdim case DeclarationName::CXXUsingDirective: 658226633Sdim Key.Data = 0; 659226633Sdim break; 660212795Sdim } 661212795Sdim 662226633Sdim return Key; 663226633Sdim} 664212795Sdim 665226633Sdimstd::pair<unsigned, unsigned> 666226633SdimASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 667226633Sdim using namespace clang::io; 668226633Sdim unsigned KeyLen = ReadUnalignedLE16(d); 669226633Sdim unsigned DataLen = ReadUnalignedLE16(d); 670226633Sdim return std::make_pair(KeyLen, DataLen); 671226633Sdim} 672212795Sdim 673226633SdimASTDeclContextNameLookupTrait::internal_key_type 674226633SdimASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) { 675226633Sdim using namespace clang::io; 676218893Sdim 677226633Sdim DeclNameKey Key; 678226633Sdim Key.Kind = (DeclarationName::NameKind)*d++; 679226633Sdim switch (Key.Kind) { 680226633Sdim case DeclarationName::Identifier: 681226633Sdim Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 682226633Sdim break; 683226633Sdim case DeclarationName::ObjCZeroArgSelector: 684226633Sdim case DeclarationName::ObjCOneArgSelector: 685226633Sdim case DeclarationName::ObjCMultiArgSelector: 686226633Sdim Key.Data = 687226633Sdim (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d)) 688226633Sdim .getAsOpaquePtr(); 689226633Sdim break; 690226633Sdim case DeclarationName::CXXOperatorName: 691226633Sdim Key.Data = *d++; // OverloadedOperatorKind 692226633Sdim break; 693226633Sdim case DeclarationName::CXXLiteralOperatorName: 694226633Sdim Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 695226633Sdim break; 696226633Sdim case DeclarationName::CXXConstructorName: 697226633Sdim case DeclarationName::CXXDestructorName: 698226633Sdim case DeclarationName::CXXConversionFunctionName: 699226633Sdim case DeclarationName::CXXUsingDirective: 700226633Sdim Key.Data = 0; 701226633Sdim break; 702212795Sdim } 703212795Sdim 704226633Sdim return Key; 705226633Sdim} 706212795Sdim 707226633SdimASTDeclContextNameLookupTrait::data_type 708226633SdimASTDeclContextNameLookupTrait::ReadData(internal_key_type, 709226633Sdim const unsigned char* d, 710234982Sdim unsigned DataLen) { 711226633Sdim using namespace clang::io; 712226633Sdim unsigned NumDecls = ReadUnalignedLE16(d); 713249423Sdim LE32DeclID *Start = reinterpret_cast<LE32DeclID *>( 714249423Sdim const_cast<unsigned char *>(d)); 715226633Sdim return std::make_pair(Start, Start + NumDecls); 716226633Sdim} 717212795Sdim 718234353Sdimbool ASTReader::ReadDeclContextStorage(ModuleFile &M, 719249423Sdim BitstreamCursor &Cursor, 720212795Sdim const std::pair<uint64_t, uint64_t> &Offsets, 721212795Sdim DeclContextInfo &Info) { 722212795Sdim SavedStreamPosition SavedPosition(Cursor); 723212795Sdim // First the lexical decls. 724212795Sdim if (Offsets.first != 0) { 725212795Sdim Cursor.JumpToBit(Offsets.first); 726212795Sdim 727212795Sdim RecordData Record; 728249423Sdim StringRef Blob; 729212795Sdim unsigned Code = Cursor.ReadCode(); 730249423Sdim unsigned RecCode = Cursor.readRecord(Code, Record, &Blob); 731212795Sdim if (RecCode != DECL_CONTEXT_LEXICAL) { 732212795Sdim Error("Expected lexical block"); 733212795Sdim return true; 734212795Sdim } 735212795Sdim 736249423Sdim Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob.data()); 737249423Sdim Info.NumLexicalDecls = Blob.size() / sizeof(KindDeclIDPair); 738212795Sdim } 739212795Sdim 740212795Sdim // Now the lookup table. 741212795Sdim if (Offsets.second != 0) { 742212795Sdim Cursor.JumpToBit(Offsets.second); 743212795Sdim 744212795Sdim RecordData Record; 745249423Sdim StringRef Blob; 746212795Sdim unsigned Code = Cursor.ReadCode(); 747249423Sdim unsigned RecCode = Cursor.readRecord(Code, Record, &Blob); 748212795Sdim if (RecCode != DECL_CONTEXT_VISIBLE) { 749212795Sdim Error("Expected visible lookup table block"); 750212795Sdim return true; 751212795Sdim } 752212795Sdim Info.NameLookupTableData 753212795Sdim = ASTDeclContextNameLookupTable::Create( 754249423Sdim (const unsigned char *)Blob.data() + Record[0], 755249423Sdim (const unsigned char *)Blob.data(), 756226633Sdim ASTDeclContextNameLookupTrait(*this, M)); 757212795Sdim } 758212795Sdim 759212795Sdim return false; 760212795Sdim} 761212795Sdim 762226633Sdimvoid ASTReader::Error(StringRef Msg) { 763221345Sdim Error(diag::err_fe_pch_malformed, Msg); 764263508Sdim if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight()) { 765263508Sdim Diag(diag::note_module_cache_path) 766263508Sdim << PP.getHeaderSearchInfo().getModuleCachePath(); 767263508Sdim } 768212795Sdim} 769212795Sdim 770221345Sdimvoid ASTReader::Error(unsigned DiagID, 771226633Sdim StringRef Arg1, StringRef Arg2) { 772221345Sdim if (Diags.isDiagnosticInFlight()) 773221345Sdim Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2); 774221345Sdim else 775221345Sdim Diag(DiagID) << Arg1 << Arg2; 776221345Sdim} 777221345Sdim 778212795Sdim//===----------------------------------------------------------------------===// 779212795Sdim// Source Manager Deserialization 780212795Sdim//===----------------------------------------------------------------------===// 781212795Sdim 782212795Sdim/// \brief Read the line table in the source manager block. 783218893Sdim/// \returns true if there was an error. 784234353Sdimbool ASTReader::ParseLineTable(ModuleFile &F, 785226633Sdim SmallVectorImpl<uint64_t> &Record) { 786212795Sdim unsigned Idx = 0; 787212795Sdim LineTableInfo &LineTable = SourceMgr.getLineTable(); 788212795Sdim 789212795Sdim // Parse the file names 790212795Sdim std::map<int, int> FileIDs; 791212795Sdim for (int I = 0, N = Record[Idx++]; I != N; ++I) { 792212795Sdim // Extract the file name 793212795Sdim unsigned FilenameLen = Record[Idx++]; 794212795Sdim std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 795212795Sdim Idx += FilenameLen; 796243830Sdim MaybeAddSystemRootToFilename(F, Filename); 797224145Sdim FileIDs[I] = LineTable.getLineTableFilenameID(Filename); 798212795Sdim } 799212795Sdim 800212795Sdim // Parse the line entries 801212795Sdim std::vector<LineEntry> Entries; 802212795Sdim while (Idx < Record.size()) { 803212795Sdim int FID = Record[Idx++]; 804226633Sdim assert(FID >= 0 && "Serialized line entries for non-local file."); 805226633Sdim // Remap FileID from 1-based old view. 806226633Sdim FID += F.SLocEntryBaseID - 1; 807212795Sdim 808212795Sdim // Extract the line entries 809212795Sdim unsigned NumEntries = Record[Idx++]; 810212795Sdim assert(NumEntries && "Numentries is 00000"); 811212795Sdim Entries.clear(); 812212795Sdim Entries.reserve(NumEntries); 813212795Sdim for (unsigned I = 0; I != NumEntries; ++I) { 814212795Sdim unsigned FileOffset = Record[Idx++]; 815212795Sdim unsigned LineNo = Record[Idx++]; 816212795Sdim int FilenameID = FileIDs[Record[Idx++]]; 817212795Sdim SrcMgr::CharacteristicKind FileKind 818212795Sdim = (SrcMgr::CharacteristicKind)Record[Idx++]; 819212795Sdim unsigned IncludeOffset = Record[Idx++]; 820212795Sdim Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 821212795Sdim FileKind, IncludeOffset)); 822212795Sdim } 823239462Sdim LineTable.AddEntry(FileID::get(FID), Entries); 824212795Sdim } 825212795Sdim 826212795Sdim return false; 827212795Sdim} 828212795Sdim 829212795Sdim/// \brief Read a source manager block 830243830Sdimbool ASTReader::ReadSourceManagerBlock(ModuleFile &F) { 831212795Sdim using namespace SrcMgr; 832212795Sdim 833249423Sdim BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 834212795Sdim 835212795Sdim // Set the source-location entry cursor to the current position in 836212795Sdim // the stream. This cursor will be used to read the contents of the 837212795Sdim // source manager block initially, and then lazily read 838212795Sdim // source-location entries as needed. 839212795Sdim SLocEntryCursor = F.Stream; 840212795Sdim 841212795Sdim // The stream itself is going to skip over the source manager block. 842212795Sdim if (F.Stream.SkipBlock()) { 843212795Sdim Error("malformed block record in AST file"); 844243830Sdim return true; 845212795Sdim } 846212795Sdim 847212795Sdim // Enter the source manager block. 848212795Sdim if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 849212795Sdim Error("malformed source manager block record in AST file"); 850243830Sdim return true; 851212795Sdim } 852212795Sdim 853212795Sdim RecordData Record; 854212795Sdim while (true) { 855249423Sdim llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks(); 856249423Sdim 857249423Sdim switch (E.Kind) { 858249423Sdim case llvm::BitstreamEntry::SubBlock: // Handled for us already. 859249423Sdim case llvm::BitstreamEntry::Error: 860249423Sdim Error("malformed block record in AST file"); 861249423Sdim return true; 862249423Sdim case llvm::BitstreamEntry::EndBlock: 863243830Sdim return false; 864249423Sdim case llvm::BitstreamEntry::Record: 865249423Sdim // The interesting case. 866249423Sdim break; 867212795Sdim } 868249423Sdim 869212795Sdim // Read a record. 870212795Sdim Record.clear(); 871249423Sdim StringRef Blob; 872249423Sdim switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) { 873212795Sdim default: // Default behavior: ignore. 874212795Sdim break; 875212795Sdim 876212795Sdim case SM_SLOC_FILE_ENTRY: 877212795Sdim case SM_SLOC_BUFFER_ENTRY: 878224145Sdim case SM_SLOC_EXPANSION_ENTRY: 879212795Sdim // Once we hit one of the source location entries, we're done. 880243830Sdim return false; 881212795Sdim } 882212795Sdim } 883212795Sdim} 884212795Sdim 885218893Sdim/// \brief If a header file is not found at the path that we expect it to be 886218893Sdim/// and the PCH file was moved from its original location, try to resolve the 887218893Sdim/// file by assuming that header+PCH were moved together and the header is in 888218893Sdim/// the same place relative to the PCH. 889218893Sdimstatic std::string 890218893SdimresolveFileRelativeToOriginalDir(const std::string &Filename, 891218893Sdim const std::string &OriginalDir, 892218893Sdim const std::string &CurrDir) { 893218893Sdim assert(OriginalDir != CurrDir && 894218893Sdim "No point trying to resolve the file if the PCH dir didn't change"); 895218893Sdim using namespace llvm::sys; 896234353Sdim SmallString<128> filePath(Filename); 897218893Sdim fs::make_absolute(filePath); 898218893Sdim assert(path::is_absolute(OriginalDir)); 899234353Sdim SmallString<128> currPCHPath(CurrDir); 900218893Sdim 901218893Sdim path::const_iterator fileDirI = path::begin(path::parent_path(filePath)), 902218893Sdim fileDirE = path::end(path::parent_path(filePath)); 903218893Sdim path::const_iterator origDirI = path::begin(OriginalDir), 904218893Sdim origDirE = path::end(OriginalDir); 905218893Sdim // Skip the common path components from filePath and OriginalDir. 906218893Sdim while (fileDirI != fileDirE && origDirI != origDirE && 907218893Sdim *fileDirI == *origDirI) { 908218893Sdim ++fileDirI; 909218893Sdim ++origDirI; 910218893Sdim } 911218893Sdim for (; origDirI != origDirE; ++origDirI) 912218893Sdim path::append(currPCHPath, ".."); 913218893Sdim path::append(currPCHPath, fileDirI, fileDirE); 914218893Sdim path::append(currPCHPath, path::filename(Filename)); 915218893Sdim return currPCHPath.str(); 916218893Sdim} 917218893Sdim 918243830Sdimbool ASTReader::ReadSLocEntry(int ID) { 919212795Sdim if (ID == 0) 920243830Sdim return false; 921212795Sdim 922226633Sdim if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 923212795Sdim Error("source location entry ID out-of-range for AST file"); 924243830Sdim return true; 925212795Sdim } 926212795Sdim 927234353Sdim ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second; 928226633Sdim F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]); 929249423Sdim BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 930226633Sdim unsigned BaseOffset = F->SLocEntryBaseOffset; 931212795Sdim 932212795Sdim ++NumSLocEntriesRead; 933249423Sdim llvm::BitstreamEntry Entry = SLocEntryCursor.advance(); 934249423Sdim if (Entry.Kind != llvm::BitstreamEntry::Record) { 935212795Sdim Error("incorrectly-formatted source location entry in AST file"); 936243830Sdim return true; 937212795Sdim } 938249423Sdim 939212795Sdim RecordData Record; 940249423Sdim StringRef Blob; 941249423Sdim switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) { 942212795Sdim default: 943212795Sdim Error("incorrectly-formatted source location entry in AST file"); 944243830Sdim return true; 945212795Sdim 946212795Sdim case SM_SLOC_FILE_ENTRY: { 947234353Sdim // We will detect whether a file changed and return 'Failure' for it, but 948234353Sdim // we will also try to fail gracefully by setting up the SLocEntry. 949243830Sdim unsigned InputID = Record[4]; 950243830Sdim InputFile IF = getInputFile(*F, InputID); 951249423Sdim const FileEntry *File = IF.getFile(); 952249423Sdim bool OverriddenBuffer = IF.isOverridden(); 953234353Sdim 954249423Sdim // Note that we only check if a File was returned. If it was out-of-date 955249423Sdim // we have complained but we will continue creating a FileID to recover 956249423Sdim // gracefully. 957249423Sdim if (!File) 958243830Sdim return true; 959212795Sdim 960226633Sdim SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 961226633Sdim if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) { 962226633Sdim // This is the module's main file. 963226633Sdim IncludeLoc = getImportLocation(F); 964226633Sdim } 965239462Sdim SrcMgr::CharacteristicKind 966239462Sdim FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; 967239462Sdim FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter, 968226633Sdim ID, BaseOffset + Record[0]); 969226633Sdim SrcMgr::FileInfo &FileInfo = 970226633Sdim const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()); 971243830Sdim FileInfo.NumCreatedFIDs = Record[5]; 972212795Sdim if (Record[3]) 973226633Sdim FileInfo.setHasLineDirectives(); 974234353Sdim 975243830Sdim const DeclID *FirstDecl = F->FileSortedDecls + Record[6]; 976243830Sdim unsigned NumFileDecls = Record[7]; 977234353Sdim if (NumFileDecls) { 978234353Sdim assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?"); 979234353Sdim FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl, 980234353Sdim NumFileDecls)); 981234353Sdim } 982218893Sdim 983234353Sdim const SrcMgr::ContentCache *ContentCache 984239462Sdim = SourceMgr.getOrCreateContentCache(File, 985239462Sdim /*isSystemFile=*/FileCharacter != SrcMgr::C_User); 986234353Sdim if (OverriddenBuffer && !ContentCache->BufferOverridden && 987234353Sdim ContentCache->ContentsEntry == ContentCache->OrigEntry) { 988234353Sdim unsigned Code = SLocEntryCursor.ReadCode(); 989234353Sdim Record.clear(); 990249423Sdim unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob); 991234353Sdim 992234353Sdim if (RecCode != SM_SLOC_BUFFER_BLOB) { 993234353Sdim Error("AST record has invalid code"); 994243830Sdim return true; 995234353Sdim } 996234353Sdim 997234353Sdim llvm::MemoryBuffer *Buffer 998249423Sdim = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), File->getName()); 999234353Sdim SourceMgr.overrideFileContents(File, Buffer); 1000234353Sdim } 1001234353Sdim 1002212795Sdim break; 1003212795Sdim } 1004212795Sdim 1005212795Sdim case SM_SLOC_BUFFER_ENTRY: { 1006249423Sdim const char *Name = Blob.data(); 1007212795Sdim unsigned Offset = Record[0]; 1008243830Sdim SrcMgr::CharacteristicKind 1009243830Sdim FileCharacter = (SrcMgr::CharacteristicKind)Record[2]; 1010243830Sdim SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 1011249423Sdim if (IncludeLoc.isInvalid() && F->Kind == MK_Module) { 1012249423Sdim IncludeLoc = getImportLocation(F); 1013249423Sdim } 1014212795Sdim unsigned Code = SLocEntryCursor.ReadCode(); 1015212795Sdim Record.clear(); 1016212795Sdim unsigned RecCode 1017249423Sdim = SLocEntryCursor.readRecord(Code, Record, &Blob); 1018212795Sdim 1019212795Sdim if (RecCode != SM_SLOC_BUFFER_BLOB) { 1020212795Sdim Error("AST record has invalid code"); 1021243830Sdim return true; 1022212795Sdim } 1023212795Sdim 1024212795Sdim llvm::MemoryBuffer *Buffer 1025249423Sdim = llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name); 1026243830Sdim SourceMgr.createFileIDForMemBuffer(Buffer, FileCharacter, ID, 1027243830Sdim BaseOffset + Offset, IncludeLoc); 1028212795Sdim break; 1029212795Sdim } 1030212795Sdim 1031224145Sdim case SM_SLOC_EXPANSION_ENTRY: { 1032218893Sdim SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1033226633Sdim SourceMgr.createExpansionLoc(SpellingLoc, 1034218893Sdim ReadSourceLocation(*F, Record[2]), 1035218893Sdim ReadSourceLocation(*F, Record[3]), 1036212795Sdim Record[4], 1037212795Sdim ID, 1038226633Sdim BaseOffset + Record[0]); 1039212795Sdim break; 1040212795Sdim } 1041212795Sdim } 1042212795Sdim 1043243830Sdim return false; 1044212795Sdim} 1045212795Sdim 1046249423Sdimstd::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) { 1047249423Sdim if (ID == 0) 1048249423Sdim return std::make_pair(SourceLocation(), ""); 1049249423Sdim 1050249423Sdim if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 1051249423Sdim Error("source location entry ID out-of-range for AST file"); 1052249423Sdim return std::make_pair(SourceLocation(), ""); 1053249423Sdim } 1054249423Sdim 1055249423Sdim // Find which module file this entry lands in. 1056249423Sdim ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second; 1057249423Sdim if (M->Kind != MK_Module) 1058249423Sdim return std::make_pair(SourceLocation(), ""); 1059249423Sdim 1060249423Sdim // FIXME: Can we map this down to a particular submodule? That would be 1061249423Sdim // ideal. 1062249423Sdim return std::make_pair(M->ImportLoc, llvm::sys::path::stem(M->FileName)); 1063249423Sdim} 1064249423Sdim 1065226633Sdim/// \brief Find the location where the module F is imported. 1066234353SdimSourceLocation ASTReader::getImportLocation(ModuleFile *F) { 1067226633Sdim if (F->ImportLoc.isValid()) 1068226633Sdim return F->ImportLoc; 1069226633Sdim 1070226633Sdim // Otherwise we have a PCH. It's considered to be "imported" at the first 1071226633Sdim // location of its includer. 1072226633Sdim if (F->ImportedBy.empty() || !F->ImportedBy[0]) { 1073226633Sdim // Main file is the importer. We assume that it is the first entry in the 1074226633Sdim // entry table. We can't ask the manager, because at the time of PCH loading 1075226633Sdim // the main file entry doesn't exist yet. 1076226633Sdim // The very first entry is the invalid instantiation loc, which takes up 1077226633Sdim // offsets 0 and 1. 1078226633Sdim return SourceLocation::getFromRawEncoding(2U); 1079226633Sdim } 1080226633Sdim //return F->Loaders[0]->FirstLoc; 1081226633Sdim return F->ImportedBy[0]->FirstLoc; 1082226633Sdim} 1083226633Sdim 1084212795Sdim/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1085212795Sdim/// specified cursor. Read the abbreviations that are at the top of the block 1086212795Sdim/// and then leave the cursor pointing into the block. 1087249423Sdimbool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) { 1088212795Sdim if (Cursor.EnterSubBlock(BlockID)) { 1089212795Sdim Error("malformed block record in AST file"); 1090212795Sdim return Failure; 1091212795Sdim } 1092212795Sdim 1093212795Sdim while (true) { 1094218893Sdim uint64_t Offset = Cursor.GetCurrentBitNo(); 1095212795Sdim unsigned Code = Cursor.ReadCode(); 1096212795Sdim 1097212795Sdim // We expect all abbrevs to be at the start of the block. 1098218893Sdim if (Code != llvm::bitc::DEFINE_ABBREV) { 1099218893Sdim Cursor.JumpToBit(Offset); 1100212795Sdim return false; 1101218893Sdim } 1102212795Sdim Cursor.ReadAbbrevRecord(); 1103212795Sdim } 1104212795Sdim} 1105212795Sdim 1106263508SdimToken ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record, 1107251662Sdim unsigned &Idx) { 1108251662Sdim Token Tok; 1109251662Sdim Tok.startToken(); 1110251662Sdim Tok.setLocation(ReadSourceLocation(F, Record, Idx)); 1111251662Sdim Tok.setLength(Record[Idx++]); 1112251662Sdim if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++])) 1113251662Sdim Tok.setIdentifierInfo(II); 1114251662Sdim Tok.setKind((tok::TokenKind)Record[Idx++]); 1115251662Sdim Tok.setFlag((Token::TokenFlags)Record[Idx++]); 1116251662Sdim return Tok; 1117251662Sdim} 1118251662Sdim 1119249423SdimMacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) { 1120249423Sdim BitstreamCursor &Stream = F.MacroCursor; 1121212795Sdim 1122212795Sdim // Keep track of where we are in the stream, then jump back there 1123212795Sdim // after reading this macro. 1124212795Sdim SavedStreamPosition SavedPosition(Stream); 1125212795Sdim 1126212795Sdim Stream.JumpToBit(Offset); 1127212795Sdim RecordData Record; 1128226633Sdim SmallVector<IdentifierInfo*, 16> MacroArgs; 1129212795Sdim MacroInfo *Macro = 0; 1130212795Sdim 1131212795Sdim while (true) { 1132249423Sdim // Advance to the next record, but if we get to the end of the block, don't 1133249423Sdim // pop it (removing all the abbreviations from the cursor) since we want to 1134249423Sdim // be able to reseek within the block and read entries. 1135249423Sdim unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd; 1136249423Sdim llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags); 1137249423Sdim 1138249423Sdim switch (Entry.Kind) { 1139249423Sdim case llvm::BitstreamEntry::SubBlock: // Handled for us already. 1140249423Sdim case llvm::BitstreamEntry::Error: 1141249423Sdim Error("malformed block record in AST file"); 1142249423Sdim return Macro; 1143249423Sdim case llvm::BitstreamEntry::EndBlock: 1144249423Sdim return Macro; 1145249423Sdim case llvm::BitstreamEntry::Record: 1146249423Sdim // The interesting case. 1147249423Sdim break; 1148212795Sdim } 1149212795Sdim 1150212795Sdim // Read a record. 1151212795Sdim Record.clear(); 1152212795Sdim PreprocessorRecordTypes RecType = 1153249423Sdim (PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record); 1154212795Sdim switch (RecType) { 1155249423Sdim case PP_MACRO_DIRECTIVE_HISTORY: 1156249423Sdim return Macro; 1157249423Sdim 1158212795Sdim case PP_MACRO_OBJECT_LIKE: 1159212795Sdim case PP_MACRO_FUNCTION_LIKE: { 1160212795Sdim // If we already have a macro, that means that we've hit the end 1161212795Sdim // of the definition of the macro we were looking for. We're 1162212795Sdim // done. 1163212795Sdim if (Macro) 1164249423Sdim return Macro; 1165212795Sdim 1166249423Sdim unsigned NextIndex = 1; // Skip identifier ID. 1167249423Sdim SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]); 1168243830Sdim SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex); 1169249423Sdim MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID); 1170249423Sdim MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex)); 1171243830Sdim MI->setIsUsed(Record[NextIndex++]); 1172212795Sdim 1173212795Sdim if (RecType == PP_MACRO_FUNCTION_LIKE) { 1174212795Sdim // Decode function-like macro info. 1175226633Sdim bool isC99VarArgs = Record[NextIndex++]; 1176226633Sdim bool isGNUVarArgs = Record[NextIndex++]; 1177249423Sdim bool hasCommaPasting = Record[NextIndex++]; 1178212795Sdim MacroArgs.clear(); 1179226633Sdim unsigned NumArgs = Record[NextIndex++]; 1180212795Sdim for (unsigned i = 0; i != NumArgs; ++i) 1181226633Sdim MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++])); 1182212795Sdim 1183212795Sdim // Install function-like macro info. 1184212795Sdim MI->setIsFunctionLike(); 1185212795Sdim if (isC99VarArgs) MI->setIsC99Varargs(); 1186212795Sdim if (isGNUVarArgs) MI->setIsGNUVarargs(); 1187249423Sdim if (hasCommaPasting) MI->setHasCommaPasting(); 1188212795Sdim MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1189226633Sdim PP.getPreprocessorAllocator()); 1190212795Sdim } 1191212795Sdim 1192212795Sdim // Remember that we saw this macro last so that we add the tokens that 1193212795Sdim // form its body to it. 1194212795Sdim Macro = MI; 1195218893Sdim 1196226633Sdim if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() && 1197226633Sdim Record[NextIndex]) { 1198226633Sdim // We have a macro definition. Register the association 1199226633Sdim PreprocessedEntityID 1200226633Sdim GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]); 1201226633Sdim PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 1202249423Sdim PreprocessingRecord::PPEntityID 1203249423Sdim PPID = PPRec.getPPEntityID(GlobalID-1, /*isLoaded=*/true); 1204249423Sdim MacroDefinition *PPDef = 1205249423Sdim cast_or_null<MacroDefinition>(PPRec.getPreprocessedEntity(PPID)); 1206249423Sdim if (PPDef) 1207249423Sdim PPRec.RegisterMacroDefinition(Macro, PPDef); 1208212795Sdim } 1209218893Sdim 1210212795Sdim ++NumMacrosRead; 1211212795Sdim break; 1212212795Sdim } 1213212795Sdim 1214212795Sdim case PP_TOKEN: { 1215212795Sdim // If we see a TOKEN before a PP_MACRO_*, then the file is 1216212795Sdim // erroneous, just pretend we didn't see this. 1217212795Sdim if (Macro == 0) break; 1218212795Sdim 1219251662Sdim unsigned Idx = 0; 1220251662Sdim Token Tok = ReadToken(F, Record, Idx); 1221212795Sdim Macro->AddTokenToBody(Tok); 1222212795Sdim break; 1223212795Sdim } 1224234353Sdim } 1225218893Sdim } 1226218893Sdim} 1227212795Sdim 1228226633SdimPreprocessedEntityID 1229234353SdimASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const { 1230226633Sdim ContinuousRangeMap<uint32_t, int, 2>::const_iterator 1231226633Sdim I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS); 1232226633Sdim assert(I != M.PreprocessedEntityRemap.end() 1233226633Sdim && "Invalid index into preprocessed entity index remap"); 1234226633Sdim 1235226633Sdim return LocalID + I->second; 1236226633Sdim} 1237212795Sdim 1238249423Sdimunsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) { 1239249423Sdim return llvm::hash_combine(ikey.Size, ikey.ModTime); 1240226633Sdim} 1241218893Sdim 1242226633SdimHeaderFileInfoTrait::internal_key_type 1243249423SdimHeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) { 1244249423Sdim internal_key_type ikey = { FE->getSize(), FE->getModificationTime(), 1245249423Sdim FE->getName() }; 1246249423Sdim return ikey; 1247249423Sdim} 1248218893Sdim 1249249423Sdimbool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) { 1250249423Sdim if (a.Size != b.Size || a.ModTime != b.ModTime) 1251249423Sdim return false; 1252249423Sdim 1253249423Sdim if (strcmp(a.Filename, b.Filename) == 0) 1254226633Sdim return true; 1255226633Sdim 1256234353Sdim // Determine whether the actual files are equivalent. 1257249423Sdim FileManager &FileMgr = Reader.getFileManager(); 1258249423Sdim const FileEntry *FEA = FileMgr.getFile(a.Filename); 1259249423Sdim const FileEntry *FEB = FileMgr.getFile(b.Filename); 1260249423Sdim return (FEA && FEA == FEB); 1261226633Sdim} 1262218893Sdim 1263226633Sdimstd::pair<unsigned, unsigned> 1264226633SdimHeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) { 1265226633Sdim unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1266226633Sdim unsigned DataLen = (unsigned) *d++; 1267249423Sdim return std::make_pair(KeyLen, DataLen); 1268226633Sdim} 1269249423Sdim 1270249423SdimHeaderFileInfoTrait::internal_key_type 1271249423SdimHeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) { 1272249423Sdim internal_key_type ikey; 1273249423Sdim ikey.Size = off_t(clang::io::ReadUnalignedLE64(d)); 1274249423Sdim ikey.ModTime = time_t(clang::io::ReadUnalignedLE64(d)); 1275249423Sdim ikey.Filename = (const char *)d; 1276249423Sdim return ikey; 1277249423Sdim} 1278249423Sdim 1279226633SdimHeaderFileInfoTrait::data_type 1280249423SdimHeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d, 1281226633Sdim unsigned DataLen) { 1282226633Sdim const unsigned char *End = d + DataLen; 1283226633Sdim using namespace clang::io; 1284226633Sdim HeaderFileInfo HFI; 1285226633Sdim unsigned Flags = *d++; 1286263508Sdim HFI.HeaderRole = static_cast<ModuleMap::ModuleHeaderRole> 1287263508Sdim ((Flags >> 6) & 0x03); 1288226633Sdim HFI.isImport = (Flags >> 5) & 0x01; 1289226633Sdim HFI.isPragmaOnce = (Flags >> 4) & 0x01; 1290226633Sdim HFI.DirInfo = (Flags >> 2) & 0x03; 1291226633Sdim HFI.Resolved = (Flags >> 1) & 0x01; 1292226633Sdim HFI.IndexHeaderMapHeader = Flags & 0x01; 1293226633Sdim HFI.NumIncludes = ReadUnalignedLE16(d); 1294234353Sdim HFI.ControllingMacroID = Reader.getGlobalIdentifierID(M, 1295234353Sdim ReadUnalignedLE32(d)); 1296226633Sdim if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) { 1297226633Sdim // The framework offset is 1 greater than the actual offset, 1298226633Sdim // since 0 is used as an indicator for "no framework name". 1299226633Sdim StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1); 1300226633Sdim HFI.Framework = HS->getUniqueFrameworkName(FrameworkName); 1301212795Sdim } 1302218893Sdim 1303249423Sdim if (d != End) { 1304249423Sdim uint32_t LocalSMID = ReadUnalignedLE32(d); 1305249423Sdim if (LocalSMID) { 1306249423Sdim // This header is part of a module. Associate it with the module to enable 1307249423Sdim // implicit module import. 1308249423Sdim SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID); 1309249423Sdim Module *Mod = Reader.getSubmodule(GlobalSMID); 1310249423Sdim HFI.isModuleHeader = true; 1311249423Sdim FileManager &FileMgr = Reader.getFileManager(); 1312249423Sdim ModuleMap &ModMap = 1313249423Sdim Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap(); 1314263508Sdim ModMap.addHeader(Mod, FileMgr.getFile(key.Filename), HFI.getHeaderRole()); 1315249423Sdim } 1316249423Sdim } 1317249423Sdim 1318226633Sdim assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1319226633Sdim (void)End; 1320218893Sdim 1321226633Sdim // This HeaderFileInfo was externally loaded. 1322226633Sdim HFI.External = true; 1323226633Sdim return HFI; 1324218893Sdim} 1325218893Sdim 1326249423Sdimvoid ASTReader::addPendingMacroFromModule(IdentifierInfo *II, 1327249423Sdim ModuleFile *M, 1328249423Sdim GlobalMacroID GMacID, 1329249423Sdim SourceLocation ImportLoc) { 1330243830Sdim assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"); 1331249423Sdim PendingMacroIDs[II].push_back(PendingMacroInfo(M, GMacID, ImportLoc)); 1332218893Sdim} 1333218893Sdim 1334249423Sdimvoid ASTReader::addPendingMacroFromPCH(IdentifierInfo *II, 1335249423Sdim ModuleFile *M, 1336249423Sdim uint64_t MacroDirectivesOffset) { 1337249423Sdim assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard"); 1338249423Sdim PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset)); 1339249423Sdim} 1340249423Sdim 1341212795Sdimvoid ASTReader::ReadDefinedMacros() { 1342243830Sdim // Note that we are loading defined macros. 1343243830Sdim Deserializing Macros(this); 1344243830Sdim 1345226633Sdim for (ModuleReverseIterator I = ModuleMgr.rbegin(), 1346226633Sdim E = ModuleMgr.rend(); I != E; ++I) { 1347249423Sdim BitstreamCursor &MacroCursor = (*I)->MacroCursor; 1348212795Sdim 1349212795Sdim // If there was no preprocessor block, skip this file. 1350212795Sdim if (!MacroCursor.getBitStreamReader()) 1351212795Sdim continue; 1352212795Sdim 1353249423Sdim BitstreamCursor Cursor = MacroCursor; 1354226633Sdim Cursor.JumpToBit((*I)->MacroStartOffset); 1355212795Sdim 1356212795Sdim RecordData Record; 1357212795Sdim while (true) { 1358249423Sdim llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks(); 1359249423Sdim 1360249423Sdim switch (E.Kind) { 1361249423Sdim case llvm::BitstreamEntry::SubBlock: // Handled for us already. 1362249423Sdim case llvm::BitstreamEntry::Error: 1363249423Sdim Error("malformed block record in AST file"); 1364249423Sdim return; 1365249423Sdim case llvm::BitstreamEntry::EndBlock: 1366249423Sdim goto NextCursor; 1367249423Sdim 1368249423Sdim case llvm::BitstreamEntry::Record: 1369249423Sdim Record.clear(); 1370249423Sdim switch (Cursor.readRecord(E.ID, Record)) { 1371249423Sdim default: // Default behavior: ignore. 1372249423Sdim break; 1373249423Sdim 1374249423Sdim case PP_MACRO_OBJECT_LIKE: 1375249423Sdim case PP_MACRO_FUNCTION_LIKE: 1376249423Sdim getLocalIdentifier(**I, Record[0]); 1377249423Sdim break; 1378249423Sdim 1379249423Sdim case PP_TOKEN: 1380249423Sdim // Ignore tokens. 1381249423Sdim break; 1382212795Sdim } 1383212795Sdim break; 1384212795Sdim } 1385212795Sdim } 1386249423Sdim NextCursor: ; 1387212795Sdim } 1388212795Sdim} 1389212795Sdim 1390234353Sdimnamespace { 1391234353Sdim /// \brief Visitor class used to look up identifirs in an AST file. 1392234353Sdim class IdentifierLookupVisitor { 1393234353Sdim StringRef Name; 1394234353Sdim unsigned PriorGeneration; 1395249423Sdim unsigned &NumIdentifierLookups; 1396249423Sdim unsigned &NumIdentifierLookupHits; 1397234353Sdim IdentifierInfo *Found; 1398249423Sdim 1399234353Sdim public: 1400249423Sdim IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration, 1401249423Sdim unsigned &NumIdentifierLookups, 1402249423Sdim unsigned &NumIdentifierLookupHits) 1403249423Sdim : Name(Name), PriorGeneration(PriorGeneration), 1404249423Sdim NumIdentifierLookups(NumIdentifierLookups), 1405249423Sdim NumIdentifierLookupHits(NumIdentifierLookupHits), 1406249423Sdim Found() 1407249423Sdim { 1408249423Sdim } 1409234353Sdim 1410234353Sdim static bool visit(ModuleFile &M, void *UserData) { 1411234353Sdim IdentifierLookupVisitor *This 1412234353Sdim = static_cast<IdentifierLookupVisitor *>(UserData); 1413234353Sdim 1414234353Sdim // If we've already searched this module file, skip it now. 1415234353Sdim if (M.Generation <= This->PriorGeneration) 1416234353Sdim return true; 1417249423Sdim 1418234353Sdim ASTIdentifierLookupTable *IdTable 1419234353Sdim = (ASTIdentifierLookupTable *)M.IdentifierLookupTable; 1420234353Sdim if (!IdTable) 1421234353Sdim return false; 1422234353Sdim 1423234353Sdim ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), 1424234353Sdim M, This->Found); 1425249423Sdim ++This->NumIdentifierLookups; 1426249423Sdim ASTIdentifierLookupTable::iterator Pos = IdTable->find(This->Name,&Trait); 1427234353Sdim if (Pos == IdTable->end()) 1428234353Sdim return false; 1429234353Sdim 1430234353Sdim // Dereferencing the iterator has the effect of building the 1431234353Sdim // IdentifierInfo node and populating it with the various 1432234353Sdim // declarations it needs. 1433249423Sdim ++This->NumIdentifierLookupHits; 1434234353Sdim This->Found = *Pos; 1435234353Sdim return true; 1436234353Sdim } 1437234353Sdim 1438234353Sdim // \brief Retrieve the identifier info found within the module 1439234353Sdim // files. 1440234353Sdim IdentifierInfo *getIdentifierInfo() const { return Found; } 1441234353Sdim }; 1442234353Sdim} 1443234353Sdim 1444234353Sdimvoid ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) { 1445243830Sdim // Note that we are loading an identifier. 1446243830Sdim Deserializing AnIdentifier(this); 1447243830Sdim 1448234353Sdim unsigned PriorGeneration = 0; 1449234353Sdim if (getContext().getLangOpts().Modules) 1450234353Sdim PriorGeneration = IdentifierGeneration[&II]; 1451249423Sdim 1452249423Sdim // If there is a global index, look there first to determine which modules 1453249423Sdim // provably do not have any results for this identifier. 1454249423Sdim GlobalModuleIndex::HitSet Hits; 1455249423Sdim GlobalModuleIndex::HitSet *HitsPtr = 0; 1456249423Sdim if (!loadGlobalIndex()) { 1457249423Sdim if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) { 1458249423Sdim HitsPtr = &Hits; 1459249423Sdim } 1460249423Sdim } 1461249423Sdim 1462249423Sdim IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration, 1463249423Sdim NumIdentifierLookups, 1464249423Sdim NumIdentifierLookupHits); 1465249423Sdim ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr); 1466234353Sdim markIdentifierUpToDate(&II); 1467234353Sdim} 1468234353Sdim 1469234353Sdimvoid ASTReader::markIdentifierUpToDate(IdentifierInfo *II) { 1470234353Sdim if (!II) 1471234353Sdim return; 1472234353Sdim 1473234353Sdim II->setOutOfDate(false); 1474234353Sdim 1475234353Sdim // Update the generation for this identifier. 1476234353Sdim if (getContext().getLangOpts().Modules) 1477234353Sdim IdentifierGeneration[II] = CurrentGeneration; 1478234353Sdim} 1479234353Sdim 1480249423Sdimvoid ASTReader::resolvePendingMacro(IdentifierInfo *II, 1481249423Sdim const PendingMacroInfo &PMInfo) { 1482249423Sdim assert(II); 1483249423Sdim 1484249423Sdim if (PMInfo.M->Kind != MK_Module) { 1485249423Sdim installPCHMacroDirectives(II, *PMInfo.M, 1486249423Sdim PMInfo.PCHMacroData.MacroDirectivesOffset); 1487249423Sdim return; 1488249423Sdim } 1489249423Sdim 1490249423Sdim // Module Macro. 1491249423Sdim 1492249423Sdim GlobalMacroID GMacID = PMInfo.ModuleMacroData.GMacID; 1493249423Sdim SourceLocation ImportLoc = 1494249423Sdim SourceLocation::getFromRawEncoding(PMInfo.ModuleMacroData.ImportLoc); 1495249423Sdim 1496249423Sdim assert(GMacID); 1497249423Sdim // If this macro has already been loaded, don't do so again. 1498249423Sdim if (MacrosLoaded[GMacID - NUM_PREDEF_MACRO_IDS]) 1499249423Sdim return; 1500249423Sdim 1501249423Sdim MacroInfo *MI = getMacro(GMacID); 1502249423Sdim SubmoduleID SubModID = MI->getOwningModuleID(); 1503249423Sdim MacroDirective *MD = PP.AllocateDefMacroDirective(MI, ImportLoc, 1504249423Sdim /*isImported=*/true); 1505249423Sdim 1506249423Sdim // Determine whether this macro definition is visible. 1507249423Sdim bool Hidden = false; 1508249423Sdim Module *Owner = 0; 1509249423Sdim if (SubModID) { 1510249423Sdim if ((Owner = getSubmodule(SubModID))) { 1511249423Sdim if (Owner->NameVisibility == Module::Hidden) { 1512249423Sdim // The owning module is not visible, and this macro definition 1513249423Sdim // should not be, either. 1514249423Sdim Hidden = true; 1515249423Sdim 1516249423Sdim // Note that this macro definition was hidden because its owning 1517249423Sdim // module is not yet visible. 1518249423Sdim HiddenNamesMap[Owner].push_back(HiddenName(II, MD)); 1519249423Sdim } 1520249423Sdim } 1521249423Sdim } 1522249423Sdim 1523249423Sdim if (!Hidden) 1524249423Sdim installImportedMacro(II, MD, Owner); 1525249423Sdim} 1526249423Sdim 1527249423Sdimvoid ASTReader::installPCHMacroDirectives(IdentifierInfo *II, 1528249423Sdim ModuleFile &M, uint64_t Offset) { 1529249423Sdim assert(M.Kind != MK_Module); 1530249423Sdim 1531249423Sdim BitstreamCursor &Cursor = M.MacroCursor; 1532249423Sdim SavedStreamPosition SavedPosition(Cursor); 1533249423Sdim Cursor.JumpToBit(Offset); 1534249423Sdim 1535249423Sdim llvm::BitstreamEntry Entry = 1536249423Sdim Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd); 1537249423Sdim if (Entry.Kind != llvm::BitstreamEntry::Record) { 1538249423Sdim Error("malformed block record in AST file"); 1539249423Sdim return; 1540249423Sdim } 1541249423Sdim 1542249423Sdim RecordData Record; 1543249423Sdim PreprocessorRecordTypes RecType = 1544249423Sdim (PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record); 1545249423Sdim if (RecType != PP_MACRO_DIRECTIVE_HISTORY) { 1546249423Sdim Error("malformed block record in AST file"); 1547249423Sdim return; 1548249423Sdim } 1549249423Sdim 1550249423Sdim // Deserialize the macro directives history in reverse source-order. 1551249423Sdim MacroDirective *Latest = 0, *Earliest = 0; 1552249423Sdim unsigned Idx = 0, N = Record.size(); 1553249423Sdim while (Idx < N) { 1554249423Sdim MacroDirective *MD = 0; 1555249423Sdim SourceLocation Loc = ReadSourceLocation(M, Record, Idx); 1556249423Sdim MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++]; 1557249423Sdim switch (K) { 1558249423Sdim case MacroDirective::MD_Define: { 1559249423Sdim GlobalMacroID GMacID = getGlobalMacroID(M, Record[Idx++]); 1560249423Sdim MacroInfo *MI = getMacro(GMacID); 1561249423Sdim bool isImported = Record[Idx++]; 1562249423Sdim bool isAmbiguous = Record[Idx++]; 1563249423Sdim DefMacroDirective *DefMD = 1564249423Sdim PP.AllocateDefMacroDirective(MI, Loc, isImported); 1565249423Sdim DefMD->setAmbiguous(isAmbiguous); 1566249423Sdim MD = DefMD; 1567249423Sdim break; 1568249423Sdim } 1569249423Sdim case MacroDirective::MD_Undefine: 1570249423Sdim MD = PP.AllocateUndefMacroDirective(Loc); 1571249423Sdim break; 1572249423Sdim case MacroDirective::MD_Visibility: { 1573249423Sdim bool isPublic = Record[Idx++]; 1574249423Sdim MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic); 1575249423Sdim break; 1576249423Sdim } 1577249423Sdim } 1578249423Sdim 1579249423Sdim if (!Latest) 1580249423Sdim Latest = MD; 1581249423Sdim if (Earliest) 1582249423Sdim Earliest->setPrevious(MD); 1583249423Sdim Earliest = MD; 1584249423Sdim } 1585249423Sdim 1586249423Sdim PP.setLoadedMacroDirective(II, Latest); 1587249423Sdim} 1588249423Sdim 1589249423Sdim/// \brief For the given macro definitions, check if they are both in system 1590251662Sdim/// modules. 1591251662Sdimstatic bool areDefinedInSystemModules(MacroInfo *PrevMI, MacroInfo *NewMI, 1592263508Sdim Module *NewOwner, ASTReader &Reader) { 1593249423Sdim assert(PrevMI && NewMI); 1594249423Sdim Module *PrevOwner = 0; 1595249423Sdim if (SubmoduleID PrevModID = PrevMI->getOwningModuleID()) 1596249423Sdim PrevOwner = Reader.getSubmodule(PrevModID); 1597263508Sdim SourceManager &SrcMgr = Reader.getSourceManager(); 1598263508Sdim bool PrevInSystem 1599263508Sdim = PrevOwner? PrevOwner->IsSystem 1600263508Sdim : SrcMgr.isInSystemHeader(PrevMI->getDefinitionLoc()); 1601263508Sdim bool NewInSystem 1602263508Sdim = NewOwner? NewOwner->IsSystem 1603263508Sdim : SrcMgr.isInSystemHeader(NewMI->getDefinitionLoc()); 1604263508Sdim if (PrevOwner && PrevOwner == NewOwner) 1605249423Sdim return false; 1606263508Sdim return PrevInSystem && NewInSystem; 1607249423Sdim} 1608249423Sdim 1609249423Sdimvoid ASTReader::installImportedMacro(IdentifierInfo *II, MacroDirective *MD, 1610249423Sdim Module *Owner) { 1611249423Sdim assert(II && MD); 1612249423Sdim 1613249423Sdim DefMacroDirective *DefMD = cast<DefMacroDirective>(MD); 1614249423Sdim MacroDirective *Prev = PP.getMacroDirective(II); 1615249423Sdim if (Prev) { 1616249423Sdim MacroDirective::DefInfo PrevDef = Prev->getDefinition(); 1617249423Sdim MacroInfo *PrevMI = PrevDef.getMacroInfo(); 1618249423Sdim MacroInfo *NewMI = DefMD->getInfo(); 1619249423Sdim if (NewMI != PrevMI && !PrevMI->isIdenticalTo(*NewMI, PP, 1620249423Sdim /*Syntactically=*/true)) { 1621249423Sdim // Before marking the macros as ambiguous, check if this is a case where 1622251662Sdim // both macros are in system headers. If so, we trust that the system 1623251662Sdim // did not get it wrong. This also handles cases where Clang's own 1624251662Sdim // headers have a different spelling of certain system macros: 1625249423Sdim // #define LONG_MAX __LONG_MAX__ (clang's limits.h) 1626249423Sdim // #define LONG_MAX 0x7fffffffffffffffL (system's limits.h) 1627251662Sdim if (!areDefinedInSystemModules(PrevMI, NewMI, Owner, *this)) { 1628249423Sdim PrevDef.getDirective()->setAmbiguous(true); 1629249423Sdim DefMD->setAmbiguous(true); 1630249423Sdim } 1631249423Sdim } 1632249423Sdim } 1633249423Sdim 1634249423Sdim PP.appendMacroDirective(II, MD); 1635249423Sdim} 1636249423Sdim 1637249423SdimInputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) { 1638243830Sdim // If this ID is bogus, just return an empty input file. 1639243830Sdim if (ID == 0 || ID > F.InputFilesLoaded.size()) 1640243830Sdim return InputFile(); 1641243830Sdim 1642243830Sdim // If we've already loaded this input file, return it. 1643249423Sdim if (F.InputFilesLoaded[ID-1].getFile()) 1644243830Sdim return F.InputFilesLoaded[ID-1]; 1645243830Sdim 1646243830Sdim // Go find this input file. 1647249423Sdim BitstreamCursor &Cursor = F.InputFilesCursor; 1648243830Sdim SavedStreamPosition SavedPosition(Cursor); 1649243830Sdim Cursor.JumpToBit(F.InputFileOffsets[ID-1]); 1650243830Sdim 1651243830Sdim unsigned Code = Cursor.ReadCode(); 1652243830Sdim RecordData Record; 1653249423Sdim StringRef Blob; 1654249423Sdim switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) { 1655243830Sdim case INPUT_FILE: { 1656243830Sdim unsigned StoredID = Record[0]; 1657243830Sdim assert(ID == StoredID && "Bogus stored ID or offset"); 1658243830Sdim (void)StoredID; 1659243830Sdim off_t StoredSize = (off_t)Record[1]; 1660243830Sdim time_t StoredTime = (time_t)Record[2]; 1661243830Sdim bool Overridden = (bool)Record[3]; 1662243830Sdim 1663243830Sdim // Get the file entry for this input file. 1664249423Sdim StringRef OrigFilename = Blob; 1665243830Sdim std::string Filename = OrigFilename; 1666243830Sdim MaybeAddSystemRootToFilename(F, Filename); 1667243830Sdim const FileEntry *File 1668243830Sdim = Overridden? FileMgr.getVirtualFile(Filename, StoredSize, StoredTime) 1669243830Sdim : FileMgr.getFile(Filename, /*OpenFile=*/false); 1670243830Sdim 1671243830Sdim // If we didn't find the file, resolve it relative to the 1672243830Sdim // original directory from which this AST file was created. 1673243830Sdim if (File == 0 && !F.OriginalDir.empty() && !CurrentDir.empty() && 1674243830Sdim F.OriginalDir != CurrentDir) { 1675243830Sdim std::string Resolved = resolveFileRelativeToOriginalDir(Filename, 1676243830Sdim F.OriginalDir, 1677243830Sdim CurrentDir); 1678243830Sdim if (!Resolved.empty()) 1679243830Sdim File = FileMgr.getFile(Resolved); 1680243830Sdim } 1681243830Sdim 1682243830Sdim // For an overridden file, create a virtual file with the stored 1683243830Sdim // size/timestamp. 1684243830Sdim if (Overridden && File == 0) { 1685243830Sdim File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime); 1686243830Sdim } 1687243830Sdim 1688243830Sdim if (File == 0) { 1689243830Sdim if (Complain) { 1690243830Sdim std::string ErrorStr = "could not find file '"; 1691243830Sdim ErrorStr += Filename; 1692243830Sdim ErrorStr += "' referenced by AST file"; 1693243830Sdim Error(ErrorStr.c_str()); 1694243830Sdim } 1695243830Sdim return InputFile(); 1696243830Sdim } 1697249423Sdim 1698243830Sdim // Check if there was a request to override the contents of the file 1699243830Sdim // that was part of the precompiled header. Overridding such a file 1700243830Sdim // can lead to problems when lexing using the source locations from the 1701243830Sdim // PCH. 1702243830Sdim SourceManager &SM = getSourceManager(); 1703243830Sdim if (!Overridden && SM.isFileOverridden(File)) { 1704249423Sdim if (Complain) 1705249423Sdim Error(diag::err_fe_pch_file_overridden, Filename); 1706243830Sdim // After emitting the diagnostic, recover by disabling the override so 1707243830Sdim // that the original file will be used. 1708243830Sdim SM.disableFileContentsOverride(File); 1709243830Sdim // The FileEntry is a virtual file entry with the size of the contents 1710243830Sdim // that would override the original contents. Set it to the original's 1711243830Sdim // size/time. 1712243830Sdim FileMgr.modifyFileEntry(const_cast<FileEntry*>(File), 1713243830Sdim StoredSize, StoredTime); 1714243830Sdim } 1715243830Sdim 1716249423Sdim bool IsOutOfDate = false; 1717249423Sdim 1718243830Sdim // For an overridden file, there is nothing to validate. 1719249423Sdim if (!Overridden && (StoredSize != File->getSize() 1720243830Sdim#if !defined(LLVM_ON_WIN32) 1721243830Sdim // In our regression testing, the Windows file system seems to 1722243830Sdim // have inconsistent modification times that sometimes 1723243830Sdim // erroneously trigger this error-handling path. 1724249423Sdim || StoredTime != File->getModificationTime() 1725243830Sdim#endif 1726243830Sdim )) { 1727249423Sdim if (Complain) { 1728249423Sdim Error(diag::err_fe_pch_file_modified, Filename, F.FileName); 1729263508Sdim if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight()) { 1730263508Sdim Diag(diag::note_module_cache_path) 1731263508Sdim << PP.getHeaderSearchInfo().getModuleCachePath(); 1732263508Sdim } 1733249423Sdim } 1734249423Sdim 1735249423Sdim IsOutOfDate = true; 1736243830Sdim } 1737243830Sdim 1738249423Sdim InputFile IF = InputFile(File, Overridden, IsOutOfDate); 1739249423Sdim 1740249423Sdim // Note that we've loaded this input file. 1741249423Sdim F.InputFilesLoaded[ID-1] = IF; 1742249423Sdim return IF; 1743243830Sdim } 1744243830Sdim } 1745243830Sdim 1746243830Sdim return InputFile(); 1747243830Sdim} 1748243830Sdim 1749226633Sdimconst FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) { 1750243830Sdim ModuleFile &M = ModuleMgr.getPrimaryModule(); 1751223017Sdim std::string Filename = filenameStrRef; 1752243830Sdim MaybeAddSystemRootToFilename(M, Filename); 1753223017Sdim const FileEntry *File = FileMgr.getFile(Filename); 1754243830Sdim if (File == 0 && !M.OriginalDir.empty() && !CurrentDir.empty() && 1755243830Sdim M.OriginalDir != CurrentDir) { 1756223017Sdim std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1757243830Sdim M.OriginalDir, 1758223017Sdim CurrentDir); 1759223017Sdim if (!resolved.empty()) 1760223017Sdim File = FileMgr.getFile(resolved); 1761223017Sdim } 1762223017Sdim 1763223017Sdim return File; 1764223017Sdim} 1765223017Sdim 1766212795Sdim/// \brief If we are loading a relocatable PCH file, and the filename is 1767212795Sdim/// not an absolute path, add the system root to the beginning of the file 1768212795Sdim/// name. 1769243830Sdimvoid ASTReader::MaybeAddSystemRootToFilename(ModuleFile &M, 1770243830Sdim std::string &Filename) { 1771212795Sdim // If this is not a relocatable PCH file, there's nothing to do. 1772243830Sdim if (!M.RelocatablePCH) 1773212795Sdim return; 1774212795Sdim 1775218893Sdim if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 1776212795Sdim return; 1777212795Sdim 1778226633Sdim if (isysroot.empty()) { 1779212795Sdim // If no system root was given, default to '/' 1780212795Sdim Filename.insert(Filename.begin(), '/'); 1781212795Sdim return; 1782212795Sdim } 1783212795Sdim 1784226633Sdim unsigned Length = isysroot.size(); 1785212795Sdim if (isysroot[Length - 1] != '/') 1786212795Sdim Filename.insert(Filename.begin(), '/'); 1787212795Sdim 1788226633Sdim Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end()); 1789212795Sdim} 1790212795Sdim 1791212795SdimASTReader::ASTReadResult 1792243830SdimASTReader::ReadControlBlock(ModuleFile &F, 1793249423Sdim SmallVectorImpl<ImportedModule> &Loaded, 1794243830Sdim unsigned ClientLoadCapabilities) { 1795249423Sdim BitstreamCursor &Stream = F.Stream; 1796212795Sdim 1797243830Sdim if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) { 1798212795Sdim Error("malformed block record in AST file"); 1799212795Sdim return Failure; 1800212795Sdim } 1801212795Sdim 1802243830Sdim // Read all of the records and blocks in the control block. 1803212795Sdim RecordData Record; 1804249423Sdim while (1) { 1805249423Sdim llvm::BitstreamEntry Entry = Stream.advance(); 1806249423Sdim 1807249423Sdim switch (Entry.Kind) { 1808249423Sdim case llvm::BitstreamEntry::Error: 1809249423Sdim Error("malformed block record in AST file"); 1810249423Sdim return Failure; 1811249423Sdim case llvm::BitstreamEntry::EndBlock: 1812249423Sdim // Validate all of the non-system input files. 1813243830Sdim if (!DisableValidation) { 1814243830Sdim bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0; 1815249423Sdim // All user input files reside at the index range [0, Record[1]). 1816249423Sdim // Record is the one from INPUT_FILE_OFFSETS. 1817249423Sdim for (unsigned I = 0, N = Record[1]; I < N; ++I) { 1818249423Sdim InputFile IF = getInputFile(F, I+1, Complain); 1819249423Sdim if (!IF.getFile() || IF.isOutOfDate()) 1820243830Sdim return OutOfDate; 1821249423Sdim } 1822243830Sdim } 1823212795Sdim return Success; 1824249423Sdim 1825249423Sdim case llvm::BitstreamEntry::SubBlock: 1826249423Sdim switch (Entry.ID) { 1827243830Sdim case INPUT_FILES_BLOCK_ID: 1828243830Sdim F.InputFilesCursor = Stream; 1829243830Sdim if (Stream.SkipBlock() || // Skip with the main cursor 1830243830Sdim // Read the abbreviations 1831243830Sdim ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) { 1832243830Sdim Error("malformed block record in AST file"); 1833243830Sdim return Failure; 1834243830Sdim } 1835243830Sdim continue; 1836249423Sdim 1837243830Sdim default: 1838249423Sdim if (Stream.SkipBlock()) { 1839249423Sdim Error("malformed block record in AST file"); 1840249423Sdim return Failure; 1841249423Sdim } 1842249423Sdim continue; 1843243830Sdim } 1844249423Sdim 1845249423Sdim case llvm::BitstreamEntry::Record: 1846249423Sdim // The interesting case. 1847249423Sdim break; 1848243830Sdim } 1849243830Sdim 1850243830Sdim // Read and process a record. 1851243830Sdim Record.clear(); 1852249423Sdim StringRef Blob; 1853249423Sdim switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) { 1854243830Sdim case METADATA: { 1855243830Sdim if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1856243830Sdim if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 1857243830Sdim Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1858243830Sdim : diag::warn_pch_version_too_new); 1859243830Sdim return VersionMismatch; 1860243830Sdim } 1861243830Sdim 1862243830Sdim bool hasErrors = Record[5]; 1863243830Sdim if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) { 1864243830Sdim Diag(diag::err_pch_with_compiler_errors); 1865243830Sdim return HadErrors; 1866243830Sdim } 1867243830Sdim 1868243830Sdim F.RelocatablePCH = Record[4]; 1869243830Sdim 1870243830Sdim const std::string &CurBranch = getClangFullRepositoryVersion(); 1871249423Sdim StringRef ASTBranch = Blob; 1872243830Sdim if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 1873243830Sdim if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 1874243830Sdim Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 1875243830Sdim return VersionMismatch; 1876243830Sdim } 1877243830Sdim break; 1878243830Sdim } 1879243830Sdim 1880243830Sdim case IMPORTS: { 1881243830Sdim // Load each of the imported PCH files. 1882243830Sdim unsigned Idx = 0, N = Record.size(); 1883243830Sdim while (Idx < N) { 1884243830Sdim // Read information about the AST file. 1885243830Sdim ModuleKind ImportedKind = (ModuleKind)Record[Idx++]; 1886249423Sdim // The import location will be the local one for now; we will adjust 1887249423Sdim // all import locations of module imports after the global source 1888249423Sdim // location info are setup. 1889249423Sdim SourceLocation ImportLoc = 1890249423Sdim SourceLocation::getFromRawEncoding(Record[Idx++]); 1891249423Sdim off_t StoredSize = (off_t)Record[Idx++]; 1892249423Sdim time_t StoredModTime = (time_t)Record[Idx++]; 1893243830Sdim unsigned Length = Record[Idx++]; 1894243830Sdim SmallString<128> ImportedFile(Record.begin() + Idx, 1895243830Sdim Record.begin() + Idx + Length); 1896243830Sdim Idx += Length; 1897243830Sdim 1898243830Sdim // Load the AST file. 1899249423Sdim switch(ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F, Loaded, 1900249423Sdim StoredSize, StoredModTime, 1901243830Sdim ClientLoadCapabilities)) { 1902243830Sdim case Failure: return Failure; 1903243830Sdim // If we have to ignore the dependency, we'll have to ignore this too. 1904249423Sdim case Missing: 1905243830Sdim case OutOfDate: return OutOfDate; 1906243830Sdim case VersionMismatch: return VersionMismatch; 1907243830Sdim case ConfigurationMismatch: return ConfigurationMismatch; 1908243830Sdim case HadErrors: return HadErrors; 1909243830Sdim case Success: break; 1910243830Sdim } 1911243830Sdim } 1912243830Sdim break; 1913243830Sdim } 1914243830Sdim 1915243830Sdim case LANGUAGE_OPTIONS: { 1916243830Sdim bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0; 1917243830Sdim if (Listener && &F == *ModuleMgr.begin() && 1918243830Sdim ParseLanguageOptions(Record, Complain, *Listener) && 1919243830Sdim !DisableValidation) 1920243830Sdim return ConfigurationMismatch; 1921243830Sdim break; 1922243830Sdim } 1923243830Sdim 1924243830Sdim case TARGET_OPTIONS: { 1925243830Sdim bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1926243830Sdim if (Listener && &F == *ModuleMgr.begin() && 1927243830Sdim ParseTargetOptions(Record, Complain, *Listener) && 1928243830Sdim !DisableValidation) 1929243830Sdim return ConfigurationMismatch; 1930243830Sdim break; 1931243830Sdim } 1932243830Sdim 1933243830Sdim case DIAGNOSTIC_OPTIONS: { 1934243830Sdim bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1935243830Sdim if (Listener && &F == *ModuleMgr.begin() && 1936243830Sdim ParseDiagnosticOptions(Record, Complain, *Listener) && 1937243830Sdim !DisableValidation) 1938243830Sdim return ConfigurationMismatch; 1939243830Sdim break; 1940243830Sdim } 1941243830Sdim 1942243830Sdim case FILE_SYSTEM_OPTIONS: { 1943243830Sdim bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1944243830Sdim if (Listener && &F == *ModuleMgr.begin() && 1945243830Sdim ParseFileSystemOptions(Record, Complain, *Listener) && 1946243830Sdim !DisableValidation) 1947243830Sdim return ConfigurationMismatch; 1948243830Sdim break; 1949243830Sdim } 1950243830Sdim 1951243830Sdim case HEADER_SEARCH_OPTIONS: { 1952243830Sdim bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1953243830Sdim if (Listener && &F == *ModuleMgr.begin() && 1954243830Sdim ParseHeaderSearchOptions(Record, Complain, *Listener) && 1955243830Sdim !DisableValidation) 1956243830Sdim return ConfigurationMismatch; 1957243830Sdim break; 1958243830Sdim } 1959243830Sdim 1960243830Sdim case PREPROCESSOR_OPTIONS: { 1961243830Sdim bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0; 1962243830Sdim if (Listener && &F == *ModuleMgr.begin() && 1963243830Sdim ParsePreprocessorOptions(Record, Complain, *Listener, 1964243830Sdim SuggestedPredefines) && 1965243830Sdim !DisableValidation) 1966243830Sdim return ConfigurationMismatch; 1967243830Sdim break; 1968243830Sdim } 1969243830Sdim 1970243830Sdim case ORIGINAL_FILE: 1971243830Sdim F.OriginalSourceFileID = FileID::get(Record[0]); 1972249423Sdim F.ActualOriginalSourceFileName = Blob; 1973243830Sdim F.OriginalSourceFileName = F.ActualOriginalSourceFileName; 1974243830Sdim MaybeAddSystemRootToFilename(F, F.OriginalSourceFileName); 1975243830Sdim break; 1976243830Sdim 1977249423Sdim case ORIGINAL_FILE_ID: 1978249423Sdim F.OriginalSourceFileID = FileID::get(Record[0]); 1979249423Sdim break; 1980249423Sdim 1981243830Sdim case ORIGINAL_PCH_DIR: 1982249423Sdim F.OriginalDir = Blob; 1983243830Sdim break; 1984243830Sdim 1985243830Sdim case INPUT_FILE_OFFSETS: 1986249423Sdim F.InputFileOffsets = (const uint32_t *)Blob.data(); 1987243830Sdim F.InputFilesLoaded.resize(Record[0]); 1988243830Sdim break; 1989243830Sdim } 1990243830Sdim } 1991243830Sdim} 1992243830Sdim 1993243830Sdimbool ASTReader::ReadASTBlock(ModuleFile &F) { 1994249423Sdim BitstreamCursor &Stream = F.Stream; 1995243830Sdim 1996243830Sdim if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1997243830Sdim Error("malformed block record in AST file"); 1998243830Sdim return true; 1999243830Sdim } 2000243830Sdim 2001243830Sdim // Read all of the records and blocks for the AST file. 2002243830Sdim RecordData Record; 2003249423Sdim while (1) { 2004249423Sdim llvm::BitstreamEntry Entry = Stream.advance(); 2005249423Sdim 2006249423Sdim switch (Entry.Kind) { 2007249423Sdim case llvm::BitstreamEntry::Error: 2008249423Sdim Error("error at end of module block in AST file"); 2009249423Sdim return true; 2010249423Sdim case llvm::BitstreamEntry::EndBlock: { 2011249423Sdim // Outside of C++, we do not store a lookup map for the translation unit. 2012249423Sdim // Instead, mark it as needing a lookup map to be built if this module 2013249423Sdim // contains any declarations lexically within it (which it always does!). 2014249423Sdim // This usually has no cost, since we very rarely need the lookup map for 2015249423Sdim // the translation unit outside C++. 2016243830Sdim DeclContext *DC = Context.getTranslationUnitDecl(); 2017249423Sdim if (DC->hasExternalLexicalStorage() && 2018249423Sdim !getContext().getLangOpts().CPlusPlus) 2019243830Sdim DC->setMustBuildLookupTable(); 2020249423Sdim 2021243830Sdim return false; 2022243830Sdim } 2023249423Sdim case llvm::BitstreamEntry::SubBlock: 2024249423Sdim switch (Entry.ID) { 2025212795Sdim case DECLTYPES_BLOCK_ID: 2026212795Sdim // We lazily load the decls block, but we want to set up the 2027212795Sdim // DeclsCursor cursor to point into it. Clone our current bitcode 2028212795Sdim // cursor to it, enter the block and read the abbrevs in that block. 2029212795Sdim // With the main cursor, we just skip over it. 2030212795Sdim F.DeclsCursor = Stream; 2031212795Sdim if (Stream.SkipBlock() || // Skip with the main cursor. 2032212795Sdim // Read the abbrevs. 2033212795Sdim ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 2034212795Sdim Error("malformed block record in AST file"); 2035243830Sdim return true; 2036212795Sdim } 2037212795Sdim break; 2038249423Sdim 2039218893Sdim case DECL_UPDATES_BLOCK_ID: 2040218893Sdim if (Stream.SkipBlock()) { 2041218893Sdim Error("malformed block record in AST file"); 2042243830Sdim return true; 2043218893Sdim } 2044218893Sdim break; 2045249423Sdim 2046212795Sdim case PREPROCESSOR_BLOCK_ID: 2047212795Sdim F.MacroCursor = Stream; 2048226633Sdim if (!PP.getExternalSource()) 2049226633Sdim PP.setExternalSource(this); 2050249423Sdim 2051218893Sdim if (Stream.SkipBlock() || 2052218893Sdim ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 2053212795Sdim Error("malformed block record in AST file"); 2054243830Sdim return true; 2055212795Sdim } 2056218893Sdim F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 2057212795Sdim break; 2058249423Sdim 2059218893Sdim case PREPROCESSOR_DETAIL_BLOCK_ID: 2060218893Sdim F.PreprocessorDetailCursor = Stream; 2061218893Sdim if (Stream.SkipBlock() || 2062249423Sdim ReadBlockAbbrevs(F.PreprocessorDetailCursor, 2063218893Sdim PREPROCESSOR_DETAIL_BLOCK_ID)) { 2064249423Sdim Error("malformed preprocessor detail record in AST file"); 2065249423Sdim return true; 2066249423Sdim } 2067218893Sdim F.PreprocessorDetailStartOffset 2068249423Sdim = F.PreprocessorDetailCursor.GetCurrentBitNo(); 2069249423Sdim 2070226633Sdim if (!PP.getPreprocessingRecord()) 2071249423Sdim PP.createPreprocessingRecord(); 2072226633Sdim if (!PP.getPreprocessingRecord()->getExternalSource()) 2073226633Sdim PP.getPreprocessingRecord()->SetExternalSource(*this); 2074218893Sdim break; 2075218893Sdim 2076212795Sdim case SOURCE_MANAGER_BLOCK_ID: 2077243830Sdim if (ReadSourceManagerBlock(F)) 2078243830Sdim return true; 2079212795Sdim break; 2080249423Sdim 2081234353Sdim case SUBMODULE_BLOCK_ID: 2082243830Sdim if (ReadSubmoduleBlock(F)) 2083243830Sdim return true; 2084234353Sdim break; 2085249423Sdim 2086239462Sdim case COMMENTS_BLOCK_ID: { 2087249423Sdim BitstreamCursor C = Stream; 2088239462Sdim if (Stream.SkipBlock() || 2089239462Sdim ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) { 2090239462Sdim Error("malformed comments block in AST file"); 2091243830Sdim return true; 2092239462Sdim } 2093239462Sdim CommentsCursors.push_back(std::make_pair(C, &F)); 2094239462Sdim break; 2095239462Sdim } 2096249423Sdim 2097234353Sdim default: 2098249423Sdim if (Stream.SkipBlock()) { 2099249423Sdim Error("malformed block record in AST file"); 2100249423Sdim return true; 2101249423Sdim } 2102249423Sdim break; 2103212795Sdim } 2104212795Sdim continue; 2105249423Sdim 2106249423Sdim case llvm::BitstreamEntry::Record: 2107249423Sdim // The interesting case. 2108249423Sdim break; 2109212795Sdim } 2110212795Sdim 2111212795Sdim // Read and process a record. 2112212795Sdim Record.clear(); 2113249423Sdim StringRef Blob; 2114249423Sdim switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) { 2115212795Sdim default: // Default behavior: ignore. 2116212795Sdim break; 2117212795Sdim 2118226633Sdim case TYPE_OFFSET: { 2119212795Sdim if (F.LocalNumTypes != 0) { 2120212795Sdim Error("duplicate TYPE_OFFSET record in AST file"); 2121243830Sdim return true; 2122212795Sdim } 2123249423Sdim F.TypeOffsets = (const uint32_t *)Blob.data(); 2124212795Sdim F.LocalNumTypes = Record[0]; 2125226633Sdim unsigned LocalBaseTypeIndex = Record[1]; 2126226633Sdim F.BaseTypeIndex = getTotalNumTypes(); 2127226633Sdim 2128226633Sdim if (F.LocalNumTypes > 0) { 2129226633Sdim // Introduce the global -> local mapping for types within this module. 2130226633Sdim GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 2131226633Sdim 2132226633Sdim // Introduce the local -> global mapping for types within this module. 2133234353Sdim F.TypeRemap.insertOrReplace( 2134234353Sdim std::make_pair(LocalBaseTypeIndex, 2135234353Sdim F.BaseTypeIndex - LocalBaseTypeIndex)); 2136226633Sdim 2137226633Sdim TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 2138226633Sdim } 2139212795Sdim break; 2140226633Sdim } 2141226633Sdim 2142226633Sdim case DECL_OFFSET: { 2143212795Sdim if (F.LocalNumDecls != 0) { 2144212795Sdim Error("duplicate DECL_OFFSET record in AST file"); 2145243830Sdim return true; 2146212795Sdim } 2147249423Sdim F.DeclOffsets = (const DeclOffset *)Blob.data(); 2148212795Sdim F.LocalNumDecls = Record[0]; 2149226633Sdim unsigned LocalBaseDeclID = Record[1]; 2150226633Sdim F.BaseDeclID = getTotalNumDecls(); 2151226633Sdim 2152226633Sdim if (F.LocalNumDecls > 0) { 2153226633Sdim // Introduce the global -> local mapping for declarations within this 2154226633Sdim // module. 2155226633Sdim GlobalDeclMap.insert( 2156226633Sdim std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F)); 2157226633Sdim 2158226633Sdim // Introduce the local -> global mapping for declarations within this 2159226633Sdim // module. 2160234353Sdim F.DeclRemap.insertOrReplace( 2161234353Sdim std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID)); 2162226633Sdim 2163234353Sdim // Introduce the global -> local mapping for declarations within this 2164234353Sdim // module. 2165234353Sdim F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID; 2166234353Sdim 2167226633Sdim DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 2168226633Sdim } 2169212795Sdim break; 2170226633Sdim } 2171226633Sdim 2172212795Sdim case TU_UPDATE_LEXICAL: { 2173226633Sdim DeclContext *TU = Context.getTranslationUnitDecl(); 2174226633Sdim DeclContextInfo &Info = F.DeclContextInfos[TU]; 2175249423Sdim Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(Blob.data()); 2176226633Sdim Info.NumLexicalDecls 2177249423Sdim = static_cast<unsigned int>(Blob.size() / sizeof(KindDeclIDPair)); 2178226633Sdim TU->setHasExternalLexicalStorage(true); 2179212795Sdim break; 2180212795Sdim } 2181212795Sdim 2182212795Sdim case UPDATE_VISIBLE: { 2183226633Sdim unsigned Idx = 0; 2184226633Sdim serialization::DeclID ID = ReadDeclID(F, Record, Idx); 2185234982Sdim ASTDeclContextNameLookupTable *Table = 2186234982Sdim ASTDeclContextNameLookupTable::Create( 2187249423Sdim (const unsigned char *)Blob.data() + Record[Idx++], 2188249423Sdim (const unsigned char *)Blob.data(), 2189226633Sdim ASTDeclContextNameLookupTrait(*this, F)); 2190226633Sdim if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU? 2191226633Sdim DeclContext *TU = Context.getTranslationUnitDecl(); 2192226633Sdim F.DeclContextInfos[TU].NameLookupTableData = Table; 2193226633Sdim TU->setHasExternalVisibleStorage(true); 2194212795Sdim } else 2195226633Sdim PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 2196212795Sdim break; 2197212795Sdim } 2198212795Sdim 2199212795Sdim case IDENTIFIER_TABLE: 2200249423Sdim F.IdentifierTableData = Blob.data(); 2201212795Sdim if (Record[0]) { 2202212795Sdim F.IdentifierLookupTable 2203212795Sdim = ASTIdentifierLookupTable::Create( 2204212795Sdim (const unsigned char *)F.IdentifierTableData + Record[0], 2205212795Sdim (const unsigned char *)F.IdentifierTableData, 2206218893Sdim ASTIdentifierLookupTrait(*this, F)); 2207226633Sdim 2208226633Sdim PP.getIdentifierTable().setExternalIdentifierLookup(this); 2209212795Sdim } 2210212795Sdim break; 2211212795Sdim 2212226633Sdim case IDENTIFIER_OFFSET: { 2213212795Sdim if (F.LocalNumIdentifiers != 0) { 2214212795Sdim Error("duplicate IDENTIFIER_OFFSET record in AST file"); 2215243830Sdim return true; 2216212795Sdim } 2217249423Sdim F.IdentifierOffsets = (const uint32_t *)Blob.data(); 2218212795Sdim F.LocalNumIdentifiers = Record[0]; 2219226633Sdim unsigned LocalBaseIdentifierID = Record[1]; 2220226633Sdim F.BaseIdentifierID = getTotalNumIdentifiers(); 2221226633Sdim 2222226633Sdim if (F.LocalNumIdentifiers > 0) { 2223226633Sdim // Introduce the global -> local mapping for identifiers within this 2224226633Sdim // module. 2225226633Sdim GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 2226226633Sdim &F)); 2227226633Sdim 2228226633Sdim // Introduce the local -> global mapping for identifiers within this 2229226633Sdim // module. 2230234353Sdim F.IdentifierRemap.insertOrReplace( 2231234353Sdim std::make_pair(LocalBaseIdentifierID, 2232234353Sdim F.BaseIdentifierID - LocalBaseIdentifierID)); 2233226633Sdim 2234226633Sdim IdentifiersLoaded.resize(IdentifiersLoaded.size() 2235226633Sdim + F.LocalNumIdentifiers); 2236226633Sdim } 2237212795Sdim break; 2238226633Sdim } 2239243830Sdim 2240212795Sdim case EXTERNAL_DEFINITIONS: 2241226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2242226633Sdim ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2243212795Sdim break; 2244212795Sdim 2245212795Sdim case SPECIAL_TYPES: 2246249423Sdim if (SpecialTypes.empty()) { 2247249423Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2248249423Sdim SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 2249249423Sdim break; 2250249423Sdim } 2251249423Sdim 2252249423Sdim if (SpecialTypes.size() != Record.size()) { 2253249423Sdim Error("invalid special-types record"); 2254249423Sdim return true; 2255249423Sdim } 2256249423Sdim 2257249423Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) { 2258249423Sdim serialization::TypeID ID = getGlobalTypeID(F, Record[I]); 2259249423Sdim if (!SpecialTypes[I]) 2260249423Sdim SpecialTypes[I] = ID; 2261249423Sdim // FIXME: If ID && SpecialTypes[I] != ID, do we need a separate 2262249423Sdim // merge step? 2263249423Sdim } 2264212795Sdim break; 2265212795Sdim 2266212795Sdim case STATISTICS: 2267212795Sdim TotalNumStatements += Record[0]; 2268212795Sdim TotalNumMacros += Record[1]; 2269212795Sdim TotalLexicalDeclContexts += Record[2]; 2270212795Sdim TotalVisibleDeclContexts += Record[3]; 2271212795Sdim break; 2272212795Sdim 2273212795Sdim case UNUSED_FILESCOPED_DECLS: 2274226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2275226633Sdim UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 2276212795Sdim break; 2277212795Sdim 2278223017Sdim case DELEGATING_CTORS: 2279226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2280226633Sdim DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 2281223017Sdim break; 2282223017Sdim 2283212795Sdim case WEAK_UNDECLARED_IDENTIFIERS: 2284226633Sdim if (Record.size() % 4 != 0) { 2285226633Sdim Error("invalid weak identifiers record"); 2286243830Sdim return true; 2287226633Sdim } 2288226633Sdim 2289226633Sdim // FIXME: Ignore weak undeclared identifiers from non-original PCH 2290226633Sdim // files. This isn't the way to do it :) 2291226633Sdim WeakUndeclaredIdentifiers.clear(); 2292226633Sdim 2293226633Sdim // Translate the weak, undeclared identifiers into global IDs. 2294226633Sdim for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 2295226633Sdim WeakUndeclaredIdentifiers.push_back( 2296226633Sdim getGlobalIdentifierID(F, Record[I++])); 2297226633Sdim WeakUndeclaredIdentifiers.push_back( 2298226633Sdim getGlobalIdentifierID(F, Record[I++])); 2299226633Sdim WeakUndeclaredIdentifiers.push_back( 2300226633Sdim ReadSourceLocation(F, Record, I).getRawEncoding()); 2301226633Sdim WeakUndeclaredIdentifiers.push_back(Record[I++]); 2302226633Sdim } 2303212795Sdim break; 2304212795Sdim 2305249423Sdim case LOCALLY_SCOPED_EXTERN_C_DECLS: 2306226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2307249423Sdim LocallyScopedExternCDecls.push_back(getGlobalDeclID(F, Record[I])); 2308212795Sdim break; 2309212795Sdim 2310226633Sdim case SELECTOR_OFFSETS: { 2311249423Sdim F.SelectorOffsets = (const uint32_t *)Blob.data(); 2312212795Sdim F.LocalNumSelectors = Record[0]; 2313226633Sdim unsigned LocalBaseSelectorID = Record[1]; 2314226633Sdim F.BaseSelectorID = getTotalNumSelectors(); 2315226633Sdim 2316226633Sdim if (F.LocalNumSelectors > 0) { 2317226633Sdim // Introduce the global -> local mapping for selectors within this 2318226633Sdim // module. 2319226633Sdim GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 2320226633Sdim 2321226633Sdim // Introduce the local -> global mapping for selectors within this 2322226633Sdim // module. 2323234353Sdim F.SelectorRemap.insertOrReplace( 2324234353Sdim std::make_pair(LocalBaseSelectorID, 2325234353Sdim F.BaseSelectorID - LocalBaseSelectorID)); 2326226633Sdim 2327226633Sdim SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 2328226633Sdim } 2329212795Sdim break; 2330226633Sdim } 2331226633Sdim 2332212795Sdim case METHOD_POOL: 2333249423Sdim F.SelectorLookupTableData = (const unsigned char *)Blob.data(); 2334212795Sdim if (Record[0]) 2335212795Sdim F.SelectorLookupTable 2336212795Sdim = ASTSelectorLookupTable::Create( 2337212795Sdim F.SelectorLookupTableData + Record[0], 2338212795Sdim F.SelectorLookupTableData, 2339226633Sdim ASTSelectorLookupTrait(*this, F)); 2340212795Sdim TotalNumMethodPoolEntries += Record[1]; 2341212795Sdim break; 2342212795Sdim 2343218893Sdim case REFERENCED_SELECTOR_POOL: 2344226633Sdim if (!Record.empty()) { 2345226633Sdim for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 2346226633Sdim ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 2347226633Sdim Record[Idx++])); 2348226633Sdim ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 2349226633Sdim getRawEncoding()); 2350226633Sdim } 2351226633Sdim } 2352212795Sdim break; 2353212795Sdim 2354212795Sdim case PP_COUNTER_VALUE: 2355212795Sdim if (!Record.empty() && Listener) 2356243830Sdim Listener->ReadCounter(F, Record[0]); 2357212795Sdim break; 2358234353Sdim 2359234353Sdim case FILE_SORTED_DECLS: 2360249423Sdim F.FileSortedDecls = (const DeclID *)Blob.data(); 2361243830Sdim F.NumFileSortedDecls = Record[0]; 2362234353Sdim break; 2363212795Sdim 2364226633Sdim case SOURCE_LOCATION_OFFSETS: { 2365249423Sdim F.SLocEntryOffsets = (const uint32_t *)Blob.data(); 2366212795Sdim F.LocalNumSLocEntries = Record[0]; 2367226633Sdim unsigned SLocSpaceSize = Record[1]; 2368226633Sdim llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 2369226633Sdim SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, 2370226633Sdim SLocSpaceSize); 2371226633Sdim // Make our entry in the range map. BaseID is negative and growing, so 2372226633Sdim // we invert it. Because we invert it, though, we need the other end of 2373226633Sdim // the range. 2374226633Sdim unsigned RangeStart = 2375226633Sdim unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 2376226633Sdim GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 2377226633Sdim F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 2378226633Sdim 2379226633Sdim // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing. 2380226633Sdim assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0); 2381226633Sdim GlobalSLocOffsetMap.insert( 2382226633Sdim std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset 2383226633Sdim - SLocSpaceSize,&F)); 2384226633Sdim 2385226633Sdim // Initialize the remapping table. 2386226633Sdim // Invalid stays invalid. 2387226633Sdim F.SLocRemap.insert(std::make_pair(0U, 0)); 2388226633Sdim // This module. Base was 2 when being compiled. 2389226633Sdim F.SLocRemap.insert(std::make_pair(2U, 2390226633Sdim static_cast<int>(F.SLocEntryBaseOffset - 2))); 2391226633Sdim 2392226633Sdim TotalNumSLocEntries += F.LocalNumSLocEntries; 2393212795Sdim break; 2394226633Sdim } 2395212795Sdim 2396226633Sdim case MODULE_OFFSET_MAP: { 2397226633Sdim // Additional remapping information. 2398249423Sdim const unsigned char *Data = (const unsigned char*)Blob.data(); 2399249423Sdim const unsigned char *DataEnd = Data + Blob.size(); 2400226633Sdim 2401226633Sdim // Continuous range maps we may be updating in our module. 2402226633Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap); 2403226633Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder 2404226633Sdim IdentifierRemap(F.IdentifierRemap); 2405243830Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder 2406243830Sdim MacroRemap(F.MacroRemap); 2407243830Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder 2408226633Sdim PreprocessedEntityRemap(F.PreprocessedEntityRemap); 2409226633Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder 2410234353Sdim SubmoduleRemap(F.SubmoduleRemap); 2411234353Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder 2412226633Sdim SelectorRemap(F.SelectorRemap); 2413226633Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap); 2414226633Sdim ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap); 2415226633Sdim 2416226633Sdim while(Data < DataEnd) { 2417226633Sdim uint16_t Len = io::ReadUnalignedLE16(Data); 2418226633Sdim StringRef Name = StringRef((const char*)Data, Len); 2419226633Sdim Data += Len; 2420234353Sdim ModuleFile *OM = ModuleMgr.lookup(Name); 2421226633Sdim if (!OM) { 2422226633Sdim Error("SourceLocation remap refers to unknown module"); 2423243830Sdim return true; 2424226633Sdim } 2425226633Sdim 2426226633Sdim uint32_t SLocOffset = io::ReadUnalignedLE32(Data); 2427226633Sdim uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data); 2428243830Sdim uint32_t MacroIDOffset = io::ReadUnalignedLE32(Data); 2429226633Sdim uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data); 2430234353Sdim uint32_t SubmoduleIDOffset = io::ReadUnalignedLE32(Data); 2431226633Sdim uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data); 2432226633Sdim uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data); 2433226633Sdim uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 2434226633Sdim 2435226633Sdim // Source location offset is mapped to OM->SLocEntryBaseOffset. 2436226633Sdim SLocRemap.insert(std::make_pair(SLocOffset, 2437226633Sdim static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 2438226633Sdim IdentifierRemap.insert( 2439226633Sdim std::make_pair(IdentifierIDOffset, 2440226633Sdim OM->BaseIdentifierID - IdentifierIDOffset)); 2441243830Sdim MacroRemap.insert(std::make_pair(MacroIDOffset, 2442243830Sdim OM->BaseMacroID - MacroIDOffset)); 2443226633Sdim PreprocessedEntityRemap.insert( 2444226633Sdim std::make_pair(PreprocessedEntityIDOffset, 2445226633Sdim OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset)); 2446234353Sdim SubmoduleRemap.insert(std::make_pair(SubmoduleIDOffset, 2447234353Sdim OM->BaseSubmoduleID - SubmoduleIDOffset)); 2448226633Sdim SelectorRemap.insert(std::make_pair(SelectorIDOffset, 2449226633Sdim OM->BaseSelectorID - SelectorIDOffset)); 2450226633Sdim DeclRemap.insert(std::make_pair(DeclIDOffset, 2451226633Sdim OM->BaseDeclID - DeclIDOffset)); 2452226633Sdim 2453226633Sdim TypeRemap.insert(std::make_pair(TypeIndexOffset, 2454226633Sdim OM->BaseTypeIndex - TypeIndexOffset)); 2455234353Sdim 2456234353Sdim // Global -> local mappings. 2457234353Sdim F.GlobalToLocalDeclIDs[OM] = DeclIDOffset; 2458226633Sdim } 2459226633Sdim break; 2460226633Sdim } 2461226633Sdim 2462226633Sdim case SOURCE_MANAGER_LINE_TABLE: 2463226633Sdim if (ParseLineTable(F, Record)) 2464243830Sdim return true; 2465226633Sdim break; 2466226633Sdim 2467226633Sdim case SOURCE_LOCATION_PRELOADS: { 2468226633Sdim // Need to transform from the local view (1-based IDs) to the global view, 2469226633Sdim // which is based off F.SLocEntryBaseID. 2470226633Sdim if (!F.PreloadSLocEntries.empty()) { 2471226633Sdim Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file"); 2472243830Sdim return true; 2473226633Sdim } 2474226633Sdim 2475226633Sdim F.PreloadSLocEntries.swap(Record); 2476212795Sdim break; 2477226633Sdim } 2478212795Sdim 2479212795Sdim case EXT_VECTOR_DECLS: 2480226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2481226633Sdim ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2482212795Sdim break; 2483212795Sdim 2484212795Sdim case VTABLE_USES: 2485226633Sdim if (Record.size() % 3 != 0) { 2486226633Sdim Error("Invalid VTABLE_USES record"); 2487243830Sdim return true; 2488226633Sdim } 2489226633Sdim 2490212795Sdim // Later tables overwrite earlier ones. 2491226633Sdim // FIXME: Modules will have some trouble with this. This is clearly not 2492226633Sdim // the right way to do this. 2493226633Sdim VTableUses.clear(); 2494226633Sdim 2495226633Sdim for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2496226633Sdim VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2497226633Sdim VTableUses.push_back( 2498226633Sdim ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2499226633Sdim VTableUses.push_back(Record[Idx++]); 2500226633Sdim } 2501212795Sdim break; 2502212795Sdim 2503212795Sdim case DYNAMIC_CLASSES: 2504226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2505226633Sdim DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2506212795Sdim break; 2507212795Sdim 2508212795Sdim case PENDING_IMPLICIT_INSTANTIATIONS: 2509226633Sdim if (PendingInstantiations.size() % 2 != 0) { 2510243830Sdim Error("Invalid existing PendingInstantiations"); 2511243830Sdim return true; 2512243830Sdim } 2513243830Sdim 2514243830Sdim if (Record.size() % 2 != 0) { 2515226633Sdim Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2516243830Sdim return true; 2517226633Sdim } 2518243830Sdim 2519226633Sdim for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2520226633Sdim PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2521226633Sdim PendingInstantiations.push_back( 2522226633Sdim ReadSourceLocation(F, Record, I).getRawEncoding()); 2523226633Sdim } 2524212795Sdim break; 2525212795Sdim 2526212795Sdim case SEMA_DECL_REFS: 2527263508Sdim if (Record.size() != 2) { 2528263508Sdim Error("Invalid SEMA_DECL_REFS block"); 2529263508Sdim return true; 2530263508Sdim } 2531226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2532226633Sdim SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2533212795Sdim break; 2534212795Sdim 2535226633Sdim case PPD_ENTITIES_OFFSETS: { 2536249423Sdim F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data(); 2537249423Sdim assert(Blob.size() % sizeof(PPEntityOffset) == 0); 2538249423Sdim F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset); 2539226633Sdim 2540226633Sdim unsigned LocalBasePreprocessedEntityID = Record[0]; 2541226633Sdim 2542226633Sdim unsigned StartingID; 2543226633Sdim if (!PP.getPreprocessingRecord()) 2544249423Sdim PP.createPreprocessingRecord(); 2545226633Sdim if (!PP.getPreprocessingRecord()->getExternalSource()) 2546226633Sdim PP.getPreprocessingRecord()->SetExternalSource(*this); 2547226633Sdim StartingID 2548226633Sdim = PP.getPreprocessingRecord() 2549226633Sdim ->allocateLoadedEntities(F.NumPreprocessedEntities); 2550226633Sdim F.BasePreprocessedEntityID = StartingID; 2551226633Sdim 2552226633Sdim if (F.NumPreprocessedEntities > 0) { 2553226633Sdim // Introduce the global -> local mapping for preprocessed entities in 2554226633Sdim // this module. 2555226633Sdim GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2556226633Sdim 2557226633Sdim // Introduce the local -> global mapping for preprocessed entities in 2558226633Sdim // this module. 2559234353Sdim F.PreprocessedEntityRemap.insertOrReplace( 2560226633Sdim std::make_pair(LocalBasePreprocessedEntityID, 2561226633Sdim F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID)); 2562226633Sdim } 2563226633Sdim 2564212795Sdim break; 2565226633Sdim } 2566226633Sdim 2567218893Sdim case DECL_UPDATE_OFFSETS: { 2568218893Sdim if (Record.size() % 2 != 0) { 2569218893Sdim Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2570243830Sdim return true; 2571218893Sdim } 2572218893Sdim for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2573226633Sdim DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2574226633Sdim .push_back(std::make_pair(&F, Record[I+1])); 2575218893Sdim break; 2576218893Sdim } 2577218893Sdim 2578212795Sdim case DECL_REPLACEMENTS: { 2579234353Sdim if (Record.size() % 3 != 0) { 2580212795Sdim Error("invalid DECL_REPLACEMENTS block in AST file"); 2581243830Sdim return true; 2582212795Sdim } 2583234353Sdim for (unsigned I = 0, N = Record.size(); I != N; I += 3) 2584226633Sdim ReplacedDecls[getGlobalDeclID(F, Record[I])] 2585234353Sdim = ReplacedDeclInfo(&F, Record[I+1], Record[I+2]); 2586212795Sdim break; 2587212795Sdim } 2588226633Sdim 2589234353Sdim case OBJC_CATEGORIES_MAP: { 2590234353Sdim if (F.LocalNumObjCCategoriesInMap != 0) { 2591234353Sdim Error("duplicate OBJC_CATEGORIES_MAP record in AST file"); 2592243830Sdim return true; 2593226633Sdim } 2594234353Sdim 2595234353Sdim F.LocalNumObjCCategoriesInMap = Record[0]; 2596249423Sdim F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data(); 2597226633Sdim break; 2598226633Sdim } 2599218893Sdim 2600234353Sdim case OBJC_CATEGORIES: 2601234353Sdim F.ObjCCategories.swap(Record); 2602234353Sdim break; 2603234353Sdim 2604218893Sdim case CXX_BASE_SPECIFIER_OFFSETS: { 2605218893Sdim if (F.LocalNumCXXBaseSpecifiers != 0) { 2606218893Sdim Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2607243830Sdim return true; 2608218893Sdim } 2609218893Sdim 2610218893Sdim F.LocalNumCXXBaseSpecifiers = Record[0]; 2611249423Sdim F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data(); 2612226633Sdim NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2613218893Sdim break; 2614218893Sdim } 2615212795Sdim 2616218893Sdim case DIAG_PRAGMA_MAPPINGS: 2617226633Sdim if (F.PragmaDiagMappings.empty()) 2618226633Sdim F.PragmaDiagMappings.swap(Record); 2619218893Sdim else 2620226633Sdim F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2621226633Sdim Record.begin(), Record.end()); 2622212795Sdim break; 2623218893Sdim 2624218893Sdim case CUDA_SPECIAL_DECL_REFS: 2625218893Sdim // Later tables overwrite earlier ones. 2626226633Sdim // FIXME: Modules will have trouble with this. 2627226633Sdim CUDASpecialDeclRefs.clear(); 2628226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2629226633Sdim CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2630218893Sdim break; 2631218893Sdim 2632226633Sdim case HEADER_SEARCH_TABLE: { 2633249423Sdim F.HeaderFileInfoTableData = Blob.data(); 2634218893Sdim F.LocalNumHeaderFileInfos = Record[1]; 2635218893Sdim if (Record[0]) { 2636218893Sdim F.HeaderFileInfoTable 2637218893Sdim = HeaderFileInfoLookupTable::Create( 2638218893Sdim (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2639226633Sdim (const unsigned char *)F.HeaderFileInfoTableData, 2640226633Sdim HeaderFileInfoTrait(*this, F, 2641226633Sdim &PP.getHeaderSearchInfo(), 2642249423Sdim Blob.data() + Record[2])); 2643226633Sdim 2644226633Sdim PP.getHeaderSearchInfo().SetExternalSource(this); 2645226633Sdim if (!PP.getHeaderSearchInfo().getExternalLookup()) 2646226633Sdim PP.getHeaderSearchInfo().SetExternalLookup(this); 2647218893Sdim } 2648218893Sdim break; 2649226633Sdim } 2650226633Sdim 2651218893Sdim case FP_PRAGMA_OPTIONS: 2652218893Sdim // Later tables overwrite earlier ones. 2653218893Sdim FPPragmaOptions.swap(Record); 2654218893Sdim break; 2655218893Sdim 2656218893Sdim case OPENCL_EXTENSIONS: 2657218893Sdim // Later tables overwrite earlier ones. 2658218893Sdim OpenCLExtensions.swap(Record); 2659218893Sdim break; 2660223017Sdim 2661223017Sdim case TENTATIVE_DEFINITIONS: 2662226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2663226633Sdim TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2664223017Sdim break; 2665224145Sdim 2666224145Sdim case KNOWN_NAMESPACES: 2667226633Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) 2668226633Sdim KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2669224145Sdim break; 2670249423Sdim 2671249423Sdim case UNDEFINED_BUT_USED: 2672249423Sdim if (UndefinedButUsed.size() % 2 != 0) { 2673249423Sdim Error("Invalid existing UndefinedButUsed"); 2674249423Sdim return true; 2675249423Sdim } 2676249423Sdim 2677249423Sdim if (Record.size() % 2 != 0) { 2678249423Sdim Error("invalid undefined-but-used record"); 2679249423Sdim return true; 2680249423Sdim } 2681249423Sdim for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2682249423Sdim UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++])); 2683249423Sdim UndefinedButUsed.push_back( 2684249423Sdim ReadSourceLocation(F, Record, I).getRawEncoding()); 2685249423Sdim } 2686249423Sdim break; 2687249423Sdim 2688234353Sdim case IMPORTED_MODULES: { 2689234353Sdim if (F.Kind != MK_Module) { 2690234353Sdim // If we aren't loading a module (which has its own exports), make 2691234353Sdim // all of the imported modules visible. 2692234353Sdim // FIXME: Deal with macros-only imports. 2693234353Sdim for (unsigned I = 0, N = Record.size(); I != N; ++I) { 2694234353Sdim if (unsigned GlobalID = getGlobalSubmoduleID(F, Record[I])) 2695234353Sdim ImportedModules.push_back(GlobalID); 2696234353Sdim } 2697234353Sdim } 2698234353Sdim break; 2699212795Sdim } 2700234353Sdim 2701234353Sdim case LOCAL_REDECLARATIONS: { 2702234353Sdim F.RedeclarationChains.swap(Record); 2703234353Sdim break; 2704234353Sdim } 2705234353Sdim 2706234353Sdim case LOCAL_REDECLARATIONS_MAP: { 2707234353Sdim if (F.LocalNumRedeclarationsInMap != 0) { 2708234353Sdim Error("duplicate LOCAL_REDECLARATIONS_MAP record in AST file"); 2709243830Sdim return true; 2710234353Sdim } 2711234353Sdim 2712234353Sdim F.LocalNumRedeclarationsInMap = Record[0]; 2713249423Sdim F.RedeclarationsMap = (const LocalRedeclarationsInfo *)Blob.data(); 2714234353Sdim break; 2715234353Sdim } 2716234353Sdim 2717234353Sdim case MERGED_DECLARATIONS: { 2718234353Sdim for (unsigned Idx = 0; Idx < Record.size(); /* increment in loop */) { 2719234353Sdim GlobalDeclID CanonID = getGlobalDeclID(F, Record[Idx++]); 2720234353Sdim SmallVectorImpl<GlobalDeclID> &Decls = StoredMergedDecls[CanonID]; 2721234353Sdim for (unsigned N = Record[Idx++]; N > 0; --N) 2722234353Sdim Decls.push_back(getGlobalDeclID(F, Record[Idx++])); 2723234353Sdim } 2724234353Sdim break; 2725234353Sdim } 2726212795Sdim 2727243830Sdim case MACRO_OFFSET: { 2728243830Sdim if (F.LocalNumMacros != 0) { 2729243830Sdim Error("duplicate MACRO_OFFSET record in AST file"); 2730243830Sdim return true; 2731243830Sdim } 2732249423Sdim F.MacroOffsets = (const uint32_t *)Blob.data(); 2733243830Sdim F.LocalNumMacros = Record[0]; 2734243830Sdim unsigned LocalBaseMacroID = Record[1]; 2735243830Sdim F.BaseMacroID = getTotalNumMacros(); 2736223017Sdim 2737243830Sdim if (F.LocalNumMacros > 0) { 2738243830Sdim // Introduce the global -> local mapping for macros within this module. 2739243830Sdim GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F)); 2740226633Sdim 2741243830Sdim // Introduce the local -> global mapping for macros within this module. 2742243830Sdim F.MacroRemap.insertOrReplace( 2743243830Sdim std::make_pair(LocalBaseMacroID, 2744243830Sdim F.BaseMacroID - LocalBaseMacroID)); 2745226633Sdim 2746243830Sdim MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros); 2747226633Sdim } 2748243830Sdim break; 2749243830Sdim } 2750226633Sdim 2751249423Sdim case MACRO_TABLE: { 2752249423Sdim // FIXME: Not used yet. 2753226633Sdim break; 2754223017Sdim } 2755263508Sdim 2756263508Sdim case LATE_PARSED_TEMPLATE: { 2757263508Sdim LateParsedTemplates.append(Record.begin(), Record.end()); 2758263508Sdim break; 2759226633Sdim } 2760263508Sdim } 2761223017Sdim } 2762223017Sdim} 2763223017Sdim 2764249423Sdim/// \brief Move the given method to the back of the global list of methods. 2765249423Sdimstatic void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) { 2766249423Sdim // Find the entry for this selector in the method pool. 2767249423Sdim Sema::GlobalMethodPool::iterator Known 2768249423Sdim = S.MethodPool.find(Method->getSelector()); 2769249423Sdim if (Known == S.MethodPool.end()) 2770249423Sdim return; 2771249423Sdim 2772249423Sdim // Retrieve the appropriate method list. 2773249423Sdim ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first 2774249423Sdim : Known->second.second; 2775249423Sdim bool Found = false; 2776251662Sdim for (ObjCMethodList *List = &Start; List; List = List->getNext()) { 2777249423Sdim if (!Found) { 2778249423Sdim if (List->Method == Method) { 2779249423Sdim Found = true; 2780249423Sdim } else { 2781249423Sdim // Keep searching. 2782249423Sdim continue; 2783249423Sdim } 2784249423Sdim } 2785249423Sdim 2786251662Sdim if (List->getNext()) 2787251662Sdim List->Method = List->getNext()->Method; 2788249423Sdim else 2789249423Sdim List->Method = Method; 2790249423Sdim } 2791249423Sdim} 2792249423Sdim 2793249423Sdimvoid ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) { 2794234353Sdim for (unsigned I = 0, N = Names.size(); I != N; ++I) { 2795243830Sdim switch (Names[I].getKind()) { 2796249423Sdim case HiddenName::Declaration: { 2797249423Sdim Decl *D = Names[I].getDecl(); 2798249423Sdim bool wasHidden = D->Hidden; 2799249423Sdim D->Hidden = false; 2800243830Sdim 2801249423Sdim if (wasHidden && SemaObj) { 2802249423Sdim if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) { 2803249423Sdim moveMethodToBackOfGlobalList(*SemaObj, Method); 2804249423Sdim } 2805234353Sdim } 2806243830Sdim break; 2807234353Sdim } 2808249423Sdim case HiddenName::MacroVisibility: { 2809249423Sdim std::pair<IdentifierInfo *, MacroDirective *> Macro = Names[I].getMacro(); 2810249423Sdim installImportedMacro(Macro.first, Macro.second, Owner); 2811243830Sdim break; 2812243830Sdim } 2813243830Sdim } 2814234353Sdim } 2815234353Sdim} 2816234353Sdim 2817234353Sdimvoid ASTReader::makeModuleVisible(Module *Mod, 2818249423Sdim Module::NameVisibilityKind NameVisibility, 2819249423Sdim SourceLocation ImportLoc, 2820249423Sdim bool Complain) { 2821234353Sdim llvm::SmallPtrSet<Module *, 4> Visited; 2822249423Sdim SmallVector<Module *, 4> Stack; 2823263508Sdim Stack.push_back(Mod); 2824234353Sdim while (!Stack.empty()) { 2825263508Sdim Mod = Stack.pop_back_val(); 2826234353Sdim 2827234353Sdim if (NameVisibility <= Mod->NameVisibility) { 2828263508Sdim // This module already has this level of visibility (or greater), so 2829234353Sdim // there is nothing more to do. 2830234353Sdim continue; 2831234353Sdim } 2832226633Sdim 2833234353Sdim if (!Mod->isAvailable()) { 2834234353Sdim // Modules that aren't available cannot be made visible. 2835234353Sdim continue; 2836234353Sdim } 2837234353Sdim 2838234353Sdim // Update the module's name visibility. 2839234353Sdim Mod->NameVisibility = NameVisibility; 2840234353Sdim 2841234353Sdim // If we've already deserialized any names from this module, 2842234353Sdim // mark them as visible. 2843234353Sdim HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod); 2844234353Sdim if (Hidden != HiddenNamesMap.end()) { 2845249423Sdim makeNamesVisible(Hidden->second, Hidden->first); 2846234353Sdim HiddenNamesMap.erase(Hidden); 2847234353Sdim } 2848263508Sdim 2849234353Sdim // Push any exported modules onto the stack to be marked as visible. 2850249423Sdim SmallVector<Module *, 16> Exports; 2851249423Sdim Mod->getExportedModules(Exports); 2852249423Sdim for (SmallVectorImpl<Module *>::iterator 2853249423Sdim I = Exports.begin(), E = Exports.end(); I != E; ++I) { 2854249423Sdim Module *Exported = *I; 2855249423Sdim if (Visited.insert(Exported)) 2856249423Sdim Stack.push_back(Exported); 2857249423Sdim } 2858234353Sdim 2859249423Sdim // Detect any conflicts. 2860249423Sdim if (Complain) { 2861249423Sdim assert(ImportLoc.isValid() && "Missing import location"); 2862249423Sdim for (unsigned I = 0, N = Mod->Conflicts.size(); I != N; ++I) { 2863249423Sdim if (Mod->Conflicts[I].Other->NameVisibility >= NameVisibility) { 2864249423Sdim Diag(ImportLoc, diag::warn_module_conflict) 2865249423Sdim << Mod->getFullModuleName() 2866249423Sdim << Mod->Conflicts[I].Other->getFullModuleName() 2867249423Sdim << Mod->Conflicts[I].Message; 2868249423Sdim // FIXME: Need note where the other module was imported. 2869234353Sdim } 2870234353Sdim } 2871226633Sdim } 2872234353Sdim } 2873226633Sdim} 2874226633Sdim 2875249423Sdimbool ASTReader::loadGlobalIndex() { 2876249423Sdim if (GlobalIndex) 2877249423Sdim return false; 2878249423Sdim 2879249423Sdim if (TriedLoadingGlobalIndex || !UseGlobalIndex || 2880249423Sdim !Context.getLangOpts().Modules) 2881249423Sdim return true; 2882249423Sdim 2883249423Sdim // Try to load the global index. 2884249423Sdim TriedLoadingGlobalIndex = true; 2885249423Sdim StringRef ModuleCachePath 2886249423Sdim = getPreprocessor().getHeaderSearchInfo().getModuleCachePath(); 2887249423Sdim std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result 2888249423Sdim = GlobalModuleIndex::readIndex(ModuleCachePath); 2889249423Sdim if (!Result.first) 2890249423Sdim return true; 2891249423Sdim 2892249423Sdim GlobalIndex.reset(Result.first); 2893249423Sdim ModuleMgr.setGlobalIndex(GlobalIndex.get()); 2894249423Sdim return false; 2895249423Sdim} 2896249423Sdim 2897249423Sdimbool ASTReader::isGlobalIndexUnavailable() const { 2898249423Sdim return Context.getLangOpts().Modules && UseGlobalIndex && 2899249423Sdim !hasGlobalIndex() && TriedLoadingGlobalIndex; 2900249423Sdim} 2901249423Sdim 2902218893SdimASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2903243830Sdim ModuleKind Type, 2904249423Sdim SourceLocation ImportLoc, 2905243830Sdim unsigned ClientLoadCapabilities) { 2906263508Sdim llvm::SaveAndRestore<SourceLocation> 2907263508Sdim SetCurImportLocRAII(CurrentImportLoc, ImportLoc); 2908263508Sdim 2909234353Sdim // Bump the generation number. 2910234353Sdim unsigned PreviousGeneration = CurrentGeneration++; 2911243830Sdim 2912243830Sdim unsigned NumModules = ModuleMgr.size(); 2913249423Sdim SmallVector<ImportedModule, 4> Loaded; 2914249423Sdim switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc, 2915243830Sdim /*ImportedBy=*/0, Loaded, 2916249423Sdim 0, 0, 2917243830Sdim ClientLoadCapabilities)) { 2918243830Sdim case Failure: 2919249423Sdim case Missing: 2920243830Sdim case OutOfDate: 2921243830Sdim case VersionMismatch: 2922243830Sdim case ConfigurationMismatch: 2923243830Sdim case HadErrors: 2924249423Sdim ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(), 2925249423Sdim Context.getLangOpts().Modules 2926249423Sdim ? &PP.getHeaderSearchInfo().getModuleMap() 2927249423Sdim : 0); 2928249423Sdim 2929249423Sdim // If we find that any modules are unusable, the global index is going 2930249423Sdim // to be out-of-date. Just remove it. 2931249423Sdim GlobalIndex.reset(); 2932249423Sdim ModuleMgr.setGlobalIndex(0); 2933243830Sdim return ReadResult; 2934243830Sdim 2935243830Sdim case Success: 2936243830Sdim break; 2937212795Sdim } 2938212795Sdim 2939212795Sdim // Here comes stuff that we only do once the entire chain is loaded. 2940234353Sdim 2941243830Sdim // Load the AST blocks of all of the modules that we loaded. 2942249423Sdim for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 2943249423Sdim MEnd = Loaded.end(); 2944243830Sdim M != MEnd; ++M) { 2945249423Sdim ModuleFile &F = *M->Mod; 2946212795Sdim 2947243830Sdim // Read the AST block. 2948243830Sdim if (ReadASTBlock(F)) 2949243830Sdim return Failure; 2950243830Sdim 2951243830Sdim // Once read, set the ModuleFile bit base offset and update the size in 2952243830Sdim // bits of all files we've seen. 2953243830Sdim F.GlobalBitOffset = TotalModulesSizeInBits; 2954243830Sdim TotalModulesSizeInBits += F.SizeInBits; 2955243830Sdim GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2956243830Sdim 2957243830Sdim // Preload SLocEntries. 2958243830Sdim for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) { 2959243830Sdim int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2960243830Sdim // Load it through the SourceManager and don't call ReadSLocEntry() 2961243830Sdim // directly because the entry may have already been loaded in which case 2962243830Sdim // calling ReadSLocEntry() directly would trigger an assertion in 2963243830Sdim // SourceManager. 2964243830Sdim SourceMgr.getLoadedSLocEntryByID(Index); 2965243830Sdim } 2966243830Sdim } 2967243830Sdim 2968249423Sdim // Setup the import locations and notify the module manager that we've 2969249423Sdim // committed to these module files. 2970249423Sdim for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(), 2971249423Sdim MEnd = Loaded.end(); 2972249423Sdim M != MEnd; ++M) { 2973249423Sdim ModuleFile &F = *M->Mod; 2974249423Sdim 2975249423Sdim ModuleMgr.moduleFileAccepted(&F); 2976249423Sdim 2977249423Sdim // Set the import location. 2978249423Sdim F.DirectImportLoc = ImportLoc; 2979249423Sdim if (!M->ImportedBy) 2980249423Sdim F.ImportLoc = M->ImportLoc; 2981249423Sdim else 2982249423Sdim F.ImportLoc = ReadSourceLocation(*M->ImportedBy, 2983249423Sdim M->ImportLoc.getRawEncoding()); 2984249423Sdim } 2985249423Sdim 2986234353Sdim // Mark all of the identifiers in the identifier table as being out of date, 2987234353Sdim // so that various accessors know to check the loaded modules when the 2988234353Sdim // identifier is used. 2989226633Sdim for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2990226633Sdim IdEnd = PP.getIdentifierTable().end(); 2991226633Sdim Id != IdEnd; ++Id) 2992234353Sdim Id->second->setOutOfDate(true); 2993226633Sdim 2994234353Sdim // Resolve any unresolved module exports. 2995249423Sdim for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) { 2996249423Sdim UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I]; 2997234353Sdim SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID); 2998234353Sdim Module *ResolvedMod = getSubmodule(GlobalID); 2999249423Sdim 3000249423Sdim switch (Unresolved.Kind) { 3001249423Sdim case UnresolvedModuleRef::Conflict: 3002249423Sdim if (ResolvedMod) { 3003249423Sdim Module::Conflict Conflict; 3004249423Sdim Conflict.Other = ResolvedMod; 3005249423Sdim Conflict.Message = Unresolved.String.str(); 3006249423Sdim Unresolved.Mod->Conflicts.push_back(Conflict); 3007249423Sdim } 3008249423Sdim continue; 3009249423Sdim 3010249423Sdim case UnresolvedModuleRef::Import: 3011234353Sdim if (ResolvedMod) 3012234353Sdim Unresolved.Mod->Imports.push_back(ResolvedMod); 3013234353Sdim continue; 3014249423Sdim 3015249423Sdim case UnresolvedModuleRef::Export: 3016249423Sdim if (ResolvedMod || Unresolved.IsWildcard) 3017249423Sdim Unresolved.Mod->Exports.push_back( 3018249423Sdim Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard)); 3019249423Sdim continue; 3020234353Sdim } 3021212795Sdim } 3022249423Sdim UnresolvedModuleRefs.clear(); 3023263508Sdim 3024263508Sdim // FIXME: How do we load the 'use'd modules? They may not be submodules. 3025263508Sdim // Might be unnecessary as use declarations are only used to build the 3026263508Sdim // module itself. 3027234353Sdim 3028226633Sdim InitializeContext(); 3029212795Sdim 3030263508Sdim if (SemaObj) 3031263508Sdim UpdateSema(); 3032263508Sdim 3033218893Sdim if (DeserializationListener) 3034218893Sdim DeserializationListener->ReaderInitialized(this); 3035218893Sdim 3036243830Sdim ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule(); 3037243830Sdim if (!PrimaryModule.OriginalSourceFileID.isInvalid()) { 3038243830Sdim PrimaryModule.OriginalSourceFileID 3039243830Sdim = FileID::get(PrimaryModule.SLocEntryBaseID 3040243830Sdim + PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1); 3041234353Sdim 3042243830Sdim // If this AST file is a precompiled preamble, then set the 3043243830Sdim // preamble file ID of the source manager to the file source file 3044243830Sdim // from which the preamble was built. 3045234353Sdim if (Type == MK_Preamble) { 3046243830Sdim SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID); 3047234353Sdim } else if (Type == MK_MainFile) { 3048243830Sdim SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID); 3049218893Sdim } 3050218893Sdim } 3051218893Sdim 3052234353Sdim // For any Objective-C class definitions we have already loaded, make sure 3053234353Sdim // that we load any additional categories. 3054234353Sdim for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) { 3055234353Sdim loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(), 3056234353Sdim ObjCClassesLoaded[I], 3057234353Sdim PreviousGeneration); 3058234353Sdim } 3059249423Sdim 3060212795Sdim return Success; 3061212795Sdim} 3062212795Sdim 3063243830SdimASTReader::ASTReadResult 3064243830SdimASTReader::ReadASTCore(StringRef FileName, 3065243830Sdim ModuleKind Type, 3066249423Sdim SourceLocation ImportLoc, 3067243830Sdim ModuleFile *ImportedBy, 3068249423Sdim SmallVectorImpl<ImportedModule> &Loaded, 3069249423Sdim off_t ExpectedSize, time_t ExpectedModTime, 3070243830Sdim unsigned ClientLoadCapabilities) { 3071234353Sdim ModuleFile *M; 3072226633Sdim std::string ErrorStr; 3073249423Sdim ModuleManager::AddModuleResult AddResult 3074249423Sdim = ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy, 3075249423Sdim CurrentGeneration, ExpectedSize, ExpectedModTime, 3076249423Sdim M, ErrorStr); 3077212795Sdim 3078249423Sdim switch (AddResult) { 3079249423Sdim case ModuleManager::AlreadyLoaded: 3080249423Sdim return Success; 3081249423Sdim 3082249423Sdim case ModuleManager::NewlyLoaded: 3083249423Sdim // Load module file below. 3084249423Sdim break; 3085249423Sdim 3086249423Sdim case ModuleManager::Missing: 3087249423Sdim // The module file was missing; if the client handle handle, that, return 3088249423Sdim // it. 3089249423Sdim if (ClientLoadCapabilities & ARR_Missing) 3090249423Sdim return Missing; 3091249423Sdim 3092249423Sdim // Otherwise, return an error. 3093249423Sdim { 3094249423Sdim std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 3095249423Sdim + ErrorStr; 3096249423Sdim Error(Msg); 3097249423Sdim } 3098226633Sdim return Failure; 3099212795Sdim 3100249423Sdim case ModuleManager::OutOfDate: 3101249423Sdim // We couldn't load the module file because it is out-of-date. If the 3102249423Sdim // client can handle out-of-date, return it. 3103249423Sdim if (ClientLoadCapabilities & ARR_OutOfDate) 3104249423Sdim return OutOfDate; 3105249423Sdim 3106249423Sdim // Otherwise, return an error. 3107249423Sdim { 3108249423Sdim std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 3109249423Sdim + ErrorStr; 3110249423Sdim Error(Msg); 3111249423Sdim } 3112249423Sdim return Failure; 3113226633Sdim } 3114226633Sdim 3115249423Sdim assert(M && "Missing module file"); 3116249423Sdim 3117226633Sdim // FIXME: This seems rather a hack. Should CurrentDir be part of the 3118226633Sdim // module? 3119218893Sdim if (FileName != "-") { 3120218893Sdim CurrentDir = llvm::sys::path::parent_path(FileName); 3121218893Sdim if (CurrentDir.empty()) CurrentDir = "."; 3122218893Sdim } 3123218893Sdim 3124234353Sdim ModuleFile &F = *M; 3125249423Sdim BitstreamCursor &Stream = F.Stream; 3126212795Sdim Stream.init(F.StreamFile); 3127212795Sdim F.SizeInBits = F.Buffer->getBufferSize() * 8; 3128226633Sdim 3129212795Sdim // Sniff for the signature. 3130212795Sdim if (Stream.Read(8) != 'C' || 3131212795Sdim Stream.Read(8) != 'P' || 3132212795Sdim Stream.Read(8) != 'C' || 3133212795Sdim Stream.Read(8) != 'H') { 3134212795Sdim Diag(diag::err_not_a_pch_file) << FileName; 3135212795Sdim return Failure; 3136212795Sdim } 3137212795Sdim 3138249423Sdim // This is used for compatibility with older PCH formats. 3139249423Sdim bool HaveReadControlBlock = false; 3140212795Sdim 3141249423Sdim while (1) { 3142249423Sdim llvm::BitstreamEntry Entry = Stream.advance(); 3143249423Sdim 3144249423Sdim switch (Entry.Kind) { 3145249423Sdim case llvm::BitstreamEntry::Error: 3146249423Sdim case llvm::BitstreamEntry::EndBlock: 3147249423Sdim case llvm::BitstreamEntry::Record: 3148212795Sdim Error("invalid record at top-level of AST file"); 3149212795Sdim return Failure; 3150249423Sdim 3151249423Sdim case llvm::BitstreamEntry::SubBlock: 3152249423Sdim break; 3153212795Sdim } 3154212795Sdim 3155243830Sdim // We only know the control subblock ID. 3156249423Sdim switch (Entry.ID) { 3157212795Sdim case llvm::bitc::BLOCKINFO_BLOCK_ID: 3158212795Sdim if (Stream.ReadBlockInfoBlock()) { 3159212795Sdim Error("malformed BlockInfoBlock in AST file"); 3160212795Sdim return Failure; 3161212795Sdim } 3162212795Sdim break; 3163243830Sdim case CONTROL_BLOCK_ID: 3164249423Sdim HaveReadControlBlock = true; 3165243830Sdim switch (ReadControlBlock(F, Loaded, ClientLoadCapabilities)) { 3166212795Sdim case Success: 3167212795Sdim break; 3168212795Sdim 3169243830Sdim case Failure: return Failure; 3170249423Sdim case Missing: return Missing; 3171243830Sdim case OutOfDate: return OutOfDate; 3172243830Sdim case VersionMismatch: return VersionMismatch; 3173243830Sdim case ConfigurationMismatch: return ConfigurationMismatch; 3174243830Sdim case HadErrors: return HadErrors; 3175212795Sdim } 3176212795Sdim break; 3177243830Sdim case AST_BLOCK_ID: 3178249423Sdim if (!HaveReadControlBlock) { 3179249423Sdim if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0) 3180249423Sdim Diag(diag::warn_pch_version_too_old); 3181249423Sdim return VersionMismatch; 3182249423Sdim } 3183249423Sdim 3184243830Sdim // Record that we've loaded this module. 3185249423Sdim Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc)); 3186243830Sdim return Success; 3187243830Sdim 3188212795Sdim default: 3189212795Sdim if (Stream.SkipBlock()) { 3190212795Sdim Error("malformed block record in AST file"); 3191212795Sdim return Failure; 3192212795Sdim } 3193212795Sdim break; 3194212795Sdim } 3195212795Sdim } 3196226633Sdim 3197226633Sdim return Success; 3198212795Sdim} 3199212795Sdim 3200226633Sdimvoid ASTReader::InitializeContext() { 3201226633Sdim // If there's a listener, notify them that we "read" the translation unit. 3202226633Sdim if (DeserializationListener) 3203226633Sdim DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 3204226633Sdim Context.getTranslationUnitDecl()); 3205212795Sdim 3206226633Sdim // Make sure we load the declaration update records for the translation unit, 3207226633Sdim // if there are any. 3208226633Sdim loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 3209226633Sdim Context.getTranslationUnitDecl()); 3210218893Sdim 3211226633Sdim // FIXME: Find a better way to deal with collisions between these 3212226633Sdim // built-in types. Right now, we just ignore the problem. 3213226633Sdim 3214212795Sdim // Load the special types. 3215234353Sdim if (SpecialTypes.size() >= NumSpecialTypeIDs) { 3216226633Sdim if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 3217226633Sdim if (!Context.CFConstantStringTypeDecl) 3218226633Sdim Context.setCFConstantStringType(GetType(String)); 3219226633Sdim } 3220226633Sdim 3221226633Sdim if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 3222226633Sdim QualType FileType = GetType(File); 3223226633Sdim if (FileType.isNull()) { 3224226633Sdim Error("FILE type is NULL"); 3225212795Sdim return; 3226212795Sdim } 3227226633Sdim 3228226633Sdim if (!Context.FILEDecl) { 3229226633Sdim if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 3230226633Sdim Context.setFILEDecl(Typedef->getDecl()); 3231226633Sdim else { 3232226633Sdim const TagType *Tag = FileType->getAs<TagType>(); 3233226633Sdim if (!Tag) { 3234226633Sdim Error("Invalid FILE type in AST file"); 3235226633Sdim return; 3236226633Sdim } 3237226633Sdim Context.setFILEDecl(Tag->getDecl()); 3238226633Sdim } 3239226633Sdim } 3240212795Sdim } 3241226633Sdim 3242234353Sdim if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) { 3243226633Sdim QualType Jmp_bufType = GetType(Jmp_buf); 3244226633Sdim if (Jmp_bufType.isNull()) { 3245226633Sdim Error("jmp_buf type is NULL"); 3246226633Sdim return; 3247226633Sdim } 3248226633Sdim 3249226633Sdim if (!Context.jmp_bufDecl) { 3250226633Sdim if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 3251226633Sdim Context.setjmp_bufDecl(Typedef->getDecl()); 3252226633Sdim else { 3253226633Sdim const TagType *Tag = Jmp_bufType->getAs<TagType>(); 3254226633Sdim if (!Tag) { 3255226633Sdim Error("Invalid jmp_buf type in AST file"); 3256226633Sdim return; 3257226633Sdim } 3258226633Sdim Context.setjmp_bufDecl(Tag->getDecl()); 3259226633Sdim } 3260226633Sdim } 3261212795Sdim } 3262226633Sdim 3263234353Sdim if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) { 3264226633Sdim QualType Sigjmp_bufType = GetType(Sigjmp_buf); 3265226633Sdim if (Sigjmp_bufType.isNull()) { 3266226633Sdim Error("sigjmp_buf type is NULL"); 3267212795Sdim return; 3268212795Sdim } 3269226633Sdim 3270226633Sdim if (!Context.sigjmp_bufDecl) { 3271226633Sdim if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 3272226633Sdim Context.setsigjmp_bufDecl(Typedef->getDecl()); 3273226633Sdim else { 3274226633Sdim const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 3275226633Sdim assert(Tag && "Invalid sigjmp_buf type in AST file"); 3276226633Sdim Context.setsigjmp_bufDecl(Tag->getDecl()); 3277226633Sdim } 3278226633Sdim } 3279212795Sdim } 3280226633Sdim 3281226633Sdim if (unsigned ObjCIdRedef 3282226633Sdim = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 3283226633Sdim if (Context.ObjCIdRedefinitionType.isNull()) 3284226633Sdim Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 3285212795Sdim } 3286226633Sdim 3287226633Sdim if (unsigned ObjCClassRedef 3288226633Sdim = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 3289226633Sdim if (Context.ObjCClassRedefinitionType.isNull()) 3290226633Sdim Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 3291212795Sdim } 3292226633Sdim 3293226633Sdim if (unsigned ObjCSelRedef 3294226633Sdim = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 3295226633Sdim if (Context.ObjCSelRedefinitionType.isNull()) 3296226633Sdim Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 3297226633Sdim } 3298227737Sdim 3299227737Sdim if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) { 3300227737Sdim QualType Ucontext_tType = GetType(Ucontext_t); 3301227737Sdim if (Ucontext_tType.isNull()) { 3302227737Sdim Error("ucontext_t type is NULL"); 3303227737Sdim return; 3304227737Sdim } 3305227737Sdim 3306227737Sdim if (!Context.ucontext_tDecl) { 3307227737Sdim if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>()) 3308227737Sdim Context.setucontext_tDecl(Typedef->getDecl()); 3309227737Sdim else { 3310227737Sdim const TagType *Tag = Ucontext_tType->getAs<TagType>(); 3311227737Sdim assert(Tag && "Invalid ucontext_t type in AST file"); 3312227737Sdim Context.setucontext_tDecl(Tag->getDecl()); 3313227737Sdim } 3314227737Sdim } 3315227737Sdim } 3316212795Sdim } 3317226633Sdim 3318226633Sdim ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 3319212795Sdim 3320218893Sdim // If there were any CUDA special declarations, deserialize them. 3321218893Sdim if (!CUDASpecialDeclRefs.empty()) { 3322218893Sdim assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 3323226633Sdim Context.setcudaConfigureCallDecl( 3324218893Sdim cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 3325218893Sdim } 3326234353Sdim 3327234353Sdim // Re-export any modules that were imported by a non-module AST file. 3328234353Sdim for (unsigned I = 0, N = ImportedModules.size(); I != N; ++I) { 3329234353Sdim if (Module *Imported = getSubmodule(ImportedModules[I])) 3330249423Sdim makeModuleVisible(Imported, Module::AllVisible, 3331249423Sdim /*ImportLoc=*/SourceLocation(), 3332249423Sdim /*Complain=*/false); 3333234353Sdim } 3334234353Sdim ImportedModules.clear(); 3335212795Sdim} 3336212795Sdim 3337234353Sdimvoid ASTReader::finalizeForWriting() { 3338234353Sdim for (HiddenNamesMapType::iterator Hidden = HiddenNamesMap.begin(), 3339234353Sdim HiddenEnd = HiddenNamesMap.end(); 3340234353Sdim Hidden != HiddenEnd; ++Hidden) { 3341249423Sdim makeNamesVisible(Hidden->second, Hidden->first); 3342234353Sdim } 3343234353Sdim HiddenNamesMap.clear(); 3344234353Sdim} 3345234353Sdim 3346251662Sdim/// \brief Given a cursor at the start of an AST file, scan ahead and drop the 3347251662Sdim/// cursor into the start of the given block ID, returning false on success and 3348251662Sdim/// true on failure. 3349251662Sdimstatic bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) { 3350249423Sdim while (1) { 3351249423Sdim llvm::BitstreamEntry Entry = Cursor.advance(); 3352249423Sdim switch (Entry.Kind) { 3353249423Sdim case llvm::BitstreamEntry::Error: 3354249423Sdim case llvm::BitstreamEntry::EndBlock: 3355249423Sdim return true; 3356249423Sdim 3357249423Sdim case llvm::BitstreamEntry::Record: 3358249423Sdim // Ignore top-level records. 3359249423Sdim Cursor.skipRecord(Entry.ID); 3360249423Sdim break; 3361249423Sdim 3362249423Sdim case llvm::BitstreamEntry::SubBlock: 3363251662Sdim if (Entry.ID == BlockID) { 3364251662Sdim if (Cursor.EnterSubBlock(BlockID)) 3365249423Sdim return true; 3366249423Sdim // Found it! 3367249423Sdim return false; 3368249423Sdim } 3369249423Sdim 3370249423Sdim if (Cursor.SkipBlock()) 3371249423Sdim return true; 3372249423Sdim } 3373249423Sdim } 3374249423Sdim} 3375249423Sdim 3376212795Sdim/// \brief Retrieve the name of the original source file name 3377212795Sdim/// directly from the AST file, without actually loading the AST 3378212795Sdim/// file. 3379212795Sdimstd::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 3380218893Sdim FileManager &FileMgr, 3381226633Sdim DiagnosticsEngine &Diags) { 3382212795Sdim // Open the AST file. 3383212795Sdim std::string ErrStr; 3384234353Sdim OwningPtr<llvm::MemoryBuffer> Buffer; 3385218893Sdim Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 3386212795Sdim if (!Buffer) { 3387239462Sdim Diags.Report(diag::err_fe_unable_to_read_pch_file) << ASTFileName << ErrStr; 3388212795Sdim return std::string(); 3389212795Sdim } 3390212795Sdim 3391212795Sdim // Initialize the stream 3392212795Sdim llvm::BitstreamReader StreamFile; 3393249423Sdim BitstreamCursor Stream; 3394212795Sdim StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3395212795Sdim (const unsigned char *)Buffer->getBufferEnd()); 3396212795Sdim Stream.init(StreamFile); 3397212795Sdim 3398212795Sdim // Sniff for the signature. 3399212795Sdim if (Stream.Read(8) != 'C' || 3400212795Sdim Stream.Read(8) != 'P' || 3401212795Sdim Stream.Read(8) != 'C' || 3402212795Sdim Stream.Read(8) != 'H') { 3403212795Sdim Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 3404212795Sdim return std::string(); 3405212795Sdim } 3406249423Sdim 3407249423Sdim // Scan for the CONTROL_BLOCK_ID block. 3408251662Sdim if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) { 3409249423Sdim Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3410249423Sdim return std::string(); 3411249423Sdim } 3412212795Sdim 3413249423Sdim // Scan for ORIGINAL_FILE inside the control block. 3414212795Sdim RecordData Record; 3415249423Sdim while (1) { 3416249423Sdim llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 3417249423Sdim if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 3418249423Sdim return std::string(); 3419249423Sdim 3420249423Sdim if (Entry.Kind != llvm::BitstreamEntry::Record) { 3421249423Sdim Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 3422249423Sdim return std::string(); 3423212795Sdim } 3424249423Sdim 3425212795Sdim Record.clear(); 3426249423Sdim StringRef Blob; 3427249423Sdim if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE) 3428249423Sdim return Blob.str(); 3429212795Sdim } 3430212795Sdim} 3431212795Sdim 3432243830Sdimnamespace { 3433243830Sdim class SimplePCHValidator : public ASTReaderListener { 3434243830Sdim const LangOptions &ExistingLangOpts; 3435243830Sdim const TargetOptions &ExistingTargetOpts; 3436243830Sdim const PreprocessorOptions &ExistingPPOpts; 3437243830Sdim FileManager &FileMgr; 3438243830Sdim 3439243830Sdim public: 3440243830Sdim SimplePCHValidator(const LangOptions &ExistingLangOpts, 3441243830Sdim const TargetOptions &ExistingTargetOpts, 3442243830Sdim const PreprocessorOptions &ExistingPPOpts, 3443243830Sdim FileManager &FileMgr) 3444243830Sdim : ExistingLangOpts(ExistingLangOpts), 3445243830Sdim ExistingTargetOpts(ExistingTargetOpts), 3446243830Sdim ExistingPPOpts(ExistingPPOpts), 3447243830Sdim FileMgr(FileMgr) 3448243830Sdim { 3449243830Sdim } 3450243830Sdim 3451243830Sdim virtual bool ReadLanguageOptions(const LangOptions &LangOpts, 3452243830Sdim bool Complain) { 3453243830Sdim return checkLanguageOptions(ExistingLangOpts, LangOpts, 0); 3454243830Sdim } 3455243830Sdim virtual bool ReadTargetOptions(const TargetOptions &TargetOpts, 3456243830Sdim bool Complain) { 3457243830Sdim return checkTargetOptions(ExistingTargetOpts, TargetOpts, 0); 3458243830Sdim } 3459243830Sdim virtual bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts, 3460243830Sdim bool Complain, 3461243830Sdim std::string &SuggestedPredefines) { 3462243830Sdim return checkPreprocessorOptions(ExistingPPOpts, PPOpts, 0, FileMgr, 3463251662Sdim SuggestedPredefines, ExistingLangOpts); 3464243830Sdim } 3465243830Sdim }; 3466243830Sdim} 3467243830Sdim 3468243830Sdimbool ASTReader::readASTFileControlBlock(StringRef Filename, 3469243830Sdim FileManager &FileMgr, 3470243830Sdim ASTReaderListener &Listener) { 3471243830Sdim // Open the AST file. 3472243830Sdim std::string ErrStr; 3473243830Sdim OwningPtr<llvm::MemoryBuffer> Buffer; 3474243830Sdim Buffer.reset(FileMgr.getBufferForFile(Filename, &ErrStr)); 3475243830Sdim if (!Buffer) { 3476243830Sdim return true; 3477243830Sdim } 3478243830Sdim 3479243830Sdim // Initialize the stream 3480243830Sdim llvm::BitstreamReader StreamFile; 3481249423Sdim BitstreamCursor Stream; 3482243830Sdim StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 3483243830Sdim (const unsigned char *)Buffer->getBufferEnd()); 3484243830Sdim Stream.init(StreamFile); 3485243830Sdim 3486243830Sdim // Sniff for the signature. 3487243830Sdim if (Stream.Read(8) != 'C' || 3488243830Sdim Stream.Read(8) != 'P' || 3489243830Sdim Stream.Read(8) != 'C' || 3490243830Sdim Stream.Read(8) != 'H') { 3491243830Sdim return true; 3492243830Sdim } 3493243830Sdim 3494249423Sdim // Scan for the CONTROL_BLOCK_ID block. 3495251662Sdim if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) 3496249423Sdim return true; 3497251662Sdim 3498251662Sdim bool NeedsInputFiles = Listener.needsInputFileVisitation(); 3499251662Sdim BitstreamCursor InputFilesCursor; 3500251662Sdim if (NeedsInputFiles) { 3501251662Sdim InputFilesCursor = Stream; 3502251662Sdim if (SkipCursorToBlock(InputFilesCursor, INPUT_FILES_BLOCK_ID)) 3503251662Sdim return true; 3504251662Sdim 3505251662Sdim // Read the abbreviations 3506251662Sdim while (true) { 3507251662Sdim uint64_t Offset = InputFilesCursor.GetCurrentBitNo(); 3508251662Sdim unsigned Code = InputFilesCursor.ReadCode(); 3509251662Sdim 3510251662Sdim // We expect all abbrevs to be at the start of the block. 3511251662Sdim if (Code != llvm::bitc::DEFINE_ABBREV) { 3512251662Sdim InputFilesCursor.JumpToBit(Offset); 3513251662Sdim break; 3514251662Sdim } 3515251662Sdim InputFilesCursor.ReadAbbrevRecord(); 3516251662Sdim } 3517251662Sdim } 3518249423Sdim 3519249423Sdim // Scan for ORIGINAL_FILE inside the control block. 3520243830Sdim RecordData Record; 3521249423Sdim while (1) { 3522249423Sdim llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(); 3523249423Sdim if (Entry.Kind == llvm::BitstreamEntry::EndBlock) 3524249423Sdim return false; 3525249423Sdim 3526249423Sdim if (Entry.Kind != llvm::BitstreamEntry::Record) 3527249423Sdim return true; 3528249423Sdim 3529249423Sdim Record.clear(); 3530249423Sdim StringRef Blob; 3531249423Sdim unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob); 3532249423Sdim switch ((ControlRecordTypes)RecCode) { 3533249423Sdim case METADATA: { 3534249423Sdim if (Record[0] != VERSION_MAJOR) 3535249423Sdim return true; 3536243830Sdim 3537249423Sdim if (Listener.ReadFullVersionInformation(Blob)) 3538249423Sdim return true; 3539249423Sdim 3540249423Sdim break; 3541249423Sdim } 3542249423Sdim case LANGUAGE_OPTIONS: 3543249423Sdim if (ParseLanguageOptions(Record, false, Listener)) 3544249423Sdim return true; 3545249423Sdim break; 3546243830Sdim 3547249423Sdim case TARGET_OPTIONS: 3548249423Sdim if (ParseTargetOptions(Record, false, Listener)) 3549249423Sdim return true; 3550249423Sdim break; 3551243830Sdim 3552249423Sdim case DIAGNOSTIC_OPTIONS: 3553249423Sdim if (ParseDiagnosticOptions(Record, false, Listener)) 3554249423Sdim return true; 3555249423Sdim break; 3556243830Sdim 3557249423Sdim case FILE_SYSTEM_OPTIONS: 3558249423Sdim if (ParseFileSystemOptions(Record, false, Listener)) 3559243830Sdim return true; 3560249423Sdim break; 3561243830Sdim 3562249423Sdim case HEADER_SEARCH_OPTIONS: 3563249423Sdim if (ParseHeaderSearchOptions(Record, false, Listener)) 3564249423Sdim return true; 3565249423Sdim break; 3566243830Sdim 3567249423Sdim case PREPROCESSOR_OPTIONS: { 3568249423Sdim std::string IgnoredSuggestedPredefines; 3569249423Sdim if (ParsePreprocessorOptions(Record, false, Listener, 3570249423Sdim IgnoredSuggestedPredefines)) 3571249423Sdim return true; 3572249423Sdim break; 3573243830Sdim } 3574243830Sdim 3575251662Sdim case INPUT_FILE_OFFSETS: { 3576251662Sdim if (!NeedsInputFiles) 3577251662Sdim break; 3578251662Sdim 3579251662Sdim unsigned NumInputFiles = Record[0]; 3580251662Sdim unsigned NumUserFiles = Record[1]; 3581251662Sdim const uint32_t *InputFileOffs = (const uint32_t *)Blob.data(); 3582251662Sdim for (unsigned I = 0; I != NumInputFiles; ++I) { 3583251662Sdim // Go find this input file. 3584251662Sdim bool isSystemFile = I >= NumUserFiles; 3585251662Sdim BitstreamCursor &Cursor = InputFilesCursor; 3586251662Sdim SavedStreamPosition SavedPosition(Cursor); 3587251662Sdim Cursor.JumpToBit(InputFileOffs[I]); 3588251662Sdim 3589251662Sdim unsigned Code = Cursor.ReadCode(); 3590251662Sdim RecordData Record; 3591251662Sdim StringRef Blob; 3592251662Sdim bool shouldContinue = false; 3593251662Sdim switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) { 3594251662Sdim case INPUT_FILE: 3595251662Sdim shouldContinue = Listener.visitInputFile(Blob, isSystemFile); 3596251662Sdim break; 3597251662Sdim } 3598251662Sdim if (!shouldContinue) 3599251662Sdim break; 3600251662Sdim } 3601251662Sdim break; 3602251662Sdim } 3603251662Sdim 3604249423Sdim default: 3605249423Sdim // No other validation to perform. 3606249423Sdim break; 3607243830Sdim } 3608243830Sdim } 3609243830Sdim} 3610243830Sdim 3611243830Sdim 3612243830Sdimbool ASTReader::isAcceptableASTFile(StringRef Filename, 3613243830Sdim FileManager &FileMgr, 3614243830Sdim const LangOptions &LangOpts, 3615243830Sdim const TargetOptions &TargetOpts, 3616243830Sdim const PreprocessorOptions &PPOpts) { 3617243830Sdim SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts, FileMgr); 3618243830Sdim return !readASTFileControlBlock(Filename, FileMgr, validator); 3619243830Sdim} 3620243830Sdim 3621243830Sdimbool ASTReader::ReadSubmoduleBlock(ModuleFile &F) { 3622234353Sdim // Enter the submodule block. 3623234353Sdim if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) { 3624234353Sdim Error("malformed submodule block record in AST file"); 3625243830Sdim return true; 3626234353Sdim } 3627234353Sdim 3628234353Sdim ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 3629234353Sdim bool First = true; 3630234353Sdim Module *CurrentModule = 0; 3631234353Sdim RecordData Record; 3632234353Sdim while (true) { 3633249423Sdim llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks(); 3634249423Sdim 3635249423Sdim switch (Entry.Kind) { 3636249423Sdim case llvm::BitstreamEntry::SubBlock: // Handled for us already. 3637249423Sdim case llvm::BitstreamEntry::Error: 3638249423Sdim Error("malformed block record in AST file"); 3639249423Sdim return true; 3640249423Sdim case llvm::BitstreamEntry::EndBlock: 3641243830Sdim return false; 3642249423Sdim case llvm::BitstreamEntry::Record: 3643249423Sdim // The interesting case. 3644249423Sdim break; 3645234353Sdim } 3646249423Sdim 3647234353Sdim // Read a record. 3648249423Sdim StringRef Blob; 3649234353Sdim Record.clear(); 3650249423Sdim switch (F.Stream.readRecord(Entry.ID, Record, &Blob)) { 3651234353Sdim default: // Default behavior: ignore. 3652234353Sdim break; 3653234353Sdim 3654234353Sdim case SUBMODULE_DEFINITION: { 3655234353Sdim if (First) { 3656234353Sdim Error("missing submodule metadata record at beginning of block"); 3657243830Sdim return true; 3658234353Sdim } 3659234353Sdim 3660249423Sdim if (Record.size() < 8) { 3661234353Sdim Error("malformed module definition"); 3662243830Sdim return true; 3663234353Sdim } 3664234353Sdim 3665249423Sdim StringRef Name = Blob; 3666234353Sdim SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[0]); 3667234353Sdim SubmoduleID Parent = getGlobalSubmoduleID(F, Record[1]); 3668234353Sdim bool IsFramework = Record[2]; 3669234353Sdim bool IsExplicit = Record[3]; 3670234353Sdim bool IsSystem = Record[4]; 3671234353Sdim bool InferSubmodules = Record[5]; 3672234353Sdim bool InferExplicitSubmodules = Record[6]; 3673234353Sdim bool InferExportWildcard = Record[7]; 3674249423Sdim bool ConfigMacrosExhaustive = Record[8]; 3675249423Sdim 3676234353Sdim Module *ParentModule = 0; 3677234353Sdim if (Parent) 3678234353Sdim ParentModule = getSubmodule(Parent); 3679234353Sdim 3680234353Sdim // Retrieve this (sub)module from the module map, creating it if 3681234353Sdim // necessary. 3682234353Sdim CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, 3683234353Sdim IsFramework, 3684234353Sdim IsExplicit).first; 3685234353Sdim SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS; 3686234353Sdim if (GlobalIndex >= SubmodulesLoaded.size() || 3687234353Sdim SubmodulesLoaded[GlobalIndex]) { 3688234353Sdim Error("too many submodules"); 3689243830Sdim return true; 3690234353Sdim } 3691249423Sdim 3692249423Sdim if (!ParentModule) { 3693249423Sdim if (const FileEntry *CurFile = CurrentModule->getASTFile()) { 3694249423Sdim if (CurFile != F.File) { 3695249423Sdim if (!Diags.isDiagnosticInFlight()) { 3696249423Sdim Diag(diag::err_module_file_conflict) 3697249423Sdim << CurrentModule->getTopLevelModuleName() 3698249423Sdim << CurFile->getName() 3699249423Sdim << F.File->getName(); 3700249423Sdim } 3701249423Sdim return true; 3702249423Sdim } 3703249423Sdim } 3704249423Sdim 3705249423Sdim CurrentModule->setASTFile(F.File); 3706249423Sdim } 3707234353Sdim 3708234353Sdim CurrentModule->IsFromModuleFile = true; 3709234353Sdim CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem; 3710234353Sdim CurrentModule->InferSubmodules = InferSubmodules; 3711234353Sdim CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules; 3712234353Sdim CurrentModule->InferExportWildcard = InferExportWildcard; 3713249423Sdim CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive; 3714234353Sdim if (DeserializationListener) 3715234353Sdim DeserializationListener->ModuleRead(GlobalID, CurrentModule); 3716234353Sdim 3717234353Sdim SubmodulesLoaded[GlobalIndex] = CurrentModule; 3718249423Sdim 3719249423Sdim // Clear out data that will be replaced by what is the module file. 3720249423Sdim CurrentModule->LinkLibraries.clear(); 3721249423Sdim CurrentModule->ConfigMacros.clear(); 3722249423Sdim CurrentModule->UnresolvedConflicts.clear(); 3723249423Sdim CurrentModule->Conflicts.clear(); 3724234353Sdim break; 3725234353Sdim } 3726234353Sdim 3727234353Sdim case SUBMODULE_UMBRELLA_HEADER: { 3728234353Sdim if (First) { 3729234353Sdim Error("missing submodule metadata record at beginning of block"); 3730243830Sdim return true; 3731234353Sdim } 3732234353Sdim 3733234353Sdim if (!CurrentModule) 3734234353Sdim break; 3735234353Sdim 3736249423Sdim if (const FileEntry *Umbrella = PP.getFileManager().getFile(Blob)) { 3737234353Sdim if (!CurrentModule->getUmbrellaHeader()) 3738234353Sdim ModMap.setUmbrellaHeader(CurrentModule, Umbrella); 3739234353Sdim else if (CurrentModule->getUmbrellaHeader() != Umbrella) { 3740234353Sdim Error("mismatched umbrella headers in submodule"); 3741243830Sdim return true; 3742234353Sdim } 3743234353Sdim } 3744234353Sdim break; 3745234353Sdim } 3746234353Sdim 3747234353Sdim case SUBMODULE_HEADER: { 3748234353Sdim if (First) { 3749234353Sdim Error("missing submodule metadata record at beginning of block"); 3750243830Sdim return true; 3751234353Sdim } 3752234353Sdim 3753234353Sdim if (!CurrentModule) 3754234353Sdim break; 3755234353Sdim 3756249423Sdim // We lazily associate headers with their modules via the HeaderInfoTable. 3757249423Sdim // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 3758249423Sdim // of complete filenames or remove it entirely. 3759234353Sdim break; 3760234353Sdim } 3761243830Sdim 3762243830Sdim case SUBMODULE_EXCLUDED_HEADER: { 3763243830Sdim if (First) { 3764243830Sdim Error("missing submodule metadata record at beginning of block"); 3765243830Sdim return true; 3766243830Sdim } 3767243830Sdim 3768243830Sdim if (!CurrentModule) 3769243830Sdim break; 3770243830Sdim 3771249423Sdim // We lazily associate headers with their modules via the HeaderInfoTable. 3772249423Sdim // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 3773249423Sdim // of complete filenames or remove it entirely. 3774243830Sdim break; 3775243830Sdim } 3776243830Sdim 3777263508Sdim case SUBMODULE_PRIVATE_HEADER: { 3778263508Sdim if (First) { 3779263508Sdim Error("missing submodule metadata record at beginning of block"); 3780263508Sdim return true; 3781263508Sdim } 3782263508Sdim 3783263508Sdim if (!CurrentModule) 3784263508Sdim break; 3785263508Sdim 3786263508Sdim // We lazily associate headers with their modules via the HeaderInfoTable. 3787263508Sdim // FIXME: Re-evaluate this section; maybe only store InputFile IDs instead 3788263508Sdim // of complete filenames or remove it entirely. 3789263508Sdim break; 3790263508Sdim } 3791263508Sdim 3792243830Sdim case SUBMODULE_TOPHEADER: { 3793243830Sdim if (First) { 3794243830Sdim Error("missing submodule metadata record at beginning of block"); 3795243830Sdim return true; 3796243830Sdim } 3797243830Sdim 3798243830Sdim if (!CurrentModule) 3799243830Sdim break; 3800243830Sdim 3801249423Sdim CurrentModule->addTopHeaderFilename(Blob); 3802243830Sdim break; 3803243830Sdim } 3804243830Sdim 3805234353Sdim case SUBMODULE_UMBRELLA_DIR: { 3806234353Sdim if (First) { 3807234353Sdim Error("missing submodule metadata record at beginning of block"); 3808243830Sdim return true; 3809234353Sdim } 3810234353Sdim 3811234353Sdim if (!CurrentModule) 3812234353Sdim break; 3813234353Sdim 3814234353Sdim if (const DirectoryEntry *Umbrella 3815249423Sdim = PP.getFileManager().getDirectory(Blob)) { 3816234353Sdim if (!CurrentModule->getUmbrellaDir()) 3817234353Sdim ModMap.setUmbrellaDir(CurrentModule, Umbrella); 3818234353Sdim else if (CurrentModule->getUmbrellaDir() != Umbrella) { 3819234353Sdim Error("mismatched umbrella directories in submodule"); 3820243830Sdim return true; 3821234353Sdim } 3822234353Sdim } 3823234353Sdim break; 3824234353Sdim } 3825234353Sdim 3826234353Sdim case SUBMODULE_METADATA: { 3827234353Sdim if (!First) { 3828234353Sdim Error("submodule metadata record not at beginning of block"); 3829243830Sdim return true; 3830234353Sdim } 3831234353Sdim First = false; 3832234353Sdim 3833234353Sdim F.BaseSubmoduleID = getTotalNumSubmodules(); 3834234353Sdim F.LocalNumSubmodules = Record[0]; 3835234353Sdim unsigned LocalBaseSubmoduleID = Record[1]; 3836234353Sdim if (F.LocalNumSubmodules > 0) { 3837234353Sdim // Introduce the global -> local mapping for submodules within this 3838234353Sdim // module. 3839234353Sdim GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F)); 3840234353Sdim 3841234353Sdim // Introduce the local -> global mapping for submodules within this 3842234353Sdim // module. 3843234353Sdim F.SubmoduleRemap.insertOrReplace( 3844234353Sdim std::make_pair(LocalBaseSubmoduleID, 3845234353Sdim F.BaseSubmoduleID - LocalBaseSubmoduleID)); 3846234353Sdim 3847234353Sdim SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules); 3848234353Sdim } 3849234353Sdim break; 3850234353Sdim } 3851234353Sdim 3852234353Sdim case SUBMODULE_IMPORTS: { 3853234353Sdim if (First) { 3854234353Sdim Error("missing submodule metadata record at beginning of block"); 3855243830Sdim return true; 3856234353Sdim } 3857234353Sdim 3858234353Sdim if (!CurrentModule) 3859234353Sdim break; 3860234353Sdim 3861234353Sdim for (unsigned Idx = 0; Idx != Record.size(); ++Idx) { 3862249423Sdim UnresolvedModuleRef Unresolved; 3863234353Sdim Unresolved.File = &F; 3864234353Sdim Unresolved.Mod = CurrentModule; 3865234353Sdim Unresolved.ID = Record[Idx]; 3866249423Sdim Unresolved.Kind = UnresolvedModuleRef::Import; 3867234353Sdim Unresolved.IsWildcard = false; 3868249423Sdim UnresolvedModuleRefs.push_back(Unresolved); 3869234353Sdim } 3870234353Sdim break; 3871234353Sdim } 3872234353Sdim 3873234353Sdim case SUBMODULE_EXPORTS: { 3874234353Sdim if (First) { 3875234353Sdim Error("missing submodule metadata record at beginning of block"); 3876243830Sdim return true; 3877234353Sdim } 3878234353Sdim 3879234353Sdim if (!CurrentModule) 3880234353Sdim break; 3881234353Sdim 3882234353Sdim for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) { 3883249423Sdim UnresolvedModuleRef Unresolved; 3884234353Sdim Unresolved.File = &F; 3885234353Sdim Unresolved.Mod = CurrentModule; 3886234353Sdim Unresolved.ID = Record[Idx]; 3887249423Sdim Unresolved.Kind = UnresolvedModuleRef::Export; 3888234353Sdim Unresolved.IsWildcard = Record[Idx + 1]; 3889249423Sdim UnresolvedModuleRefs.push_back(Unresolved); 3890234353Sdim } 3891234353Sdim 3892234353Sdim // Once we've loaded the set of exports, there's no reason to keep 3893234353Sdim // the parsed, unresolved exports around. 3894234353Sdim CurrentModule->UnresolvedExports.clear(); 3895234353Sdim break; 3896234353Sdim } 3897234353Sdim case SUBMODULE_REQUIRES: { 3898234353Sdim if (First) { 3899234353Sdim Error("missing submodule metadata record at beginning of block"); 3900243830Sdim return true; 3901234353Sdim } 3902234353Sdim 3903234353Sdim if (!CurrentModule) 3904234353Sdim break; 3905234353Sdim 3906263508Sdim CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(), 3907234353Sdim Context.getTargetInfo()); 3908234353Sdim break; 3909234353Sdim } 3910249423Sdim 3911249423Sdim case SUBMODULE_LINK_LIBRARY: 3912249423Sdim if (First) { 3913249423Sdim Error("missing submodule metadata record at beginning of block"); 3914249423Sdim return true; 3915249423Sdim } 3916249423Sdim 3917249423Sdim if (!CurrentModule) 3918249423Sdim break; 3919249423Sdim 3920249423Sdim CurrentModule->LinkLibraries.push_back( 3921249423Sdim Module::LinkLibrary(Blob, Record[0])); 3922249423Sdim break; 3923249423Sdim 3924249423Sdim case SUBMODULE_CONFIG_MACRO: 3925249423Sdim if (First) { 3926249423Sdim Error("missing submodule metadata record at beginning of block"); 3927249423Sdim return true; 3928249423Sdim } 3929249423Sdim 3930249423Sdim if (!CurrentModule) 3931249423Sdim break; 3932249423Sdim 3933249423Sdim CurrentModule->ConfigMacros.push_back(Blob.str()); 3934249423Sdim break; 3935249423Sdim 3936249423Sdim case SUBMODULE_CONFLICT: { 3937249423Sdim if (First) { 3938249423Sdim Error("missing submodule metadata record at beginning of block"); 3939249423Sdim return true; 3940249423Sdim } 3941249423Sdim 3942249423Sdim if (!CurrentModule) 3943249423Sdim break; 3944249423Sdim 3945249423Sdim UnresolvedModuleRef Unresolved; 3946249423Sdim Unresolved.File = &F; 3947249423Sdim Unresolved.Mod = CurrentModule; 3948249423Sdim Unresolved.ID = Record[0]; 3949249423Sdim Unresolved.Kind = UnresolvedModuleRef::Conflict; 3950249423Sdim Unresolved.IsWildcard = false; 3951249423Sdim Unresolved.String = Blob; 3952249423Sdim UnresolvedModuleRefs.push_back(Unresolved); 3953249423Sdim break; 3954234353Sdim } 3955249423Sdim } 3956234353Sdim } 3957234353Sdim} 3958234353Sdim 3959212795Sdim/// \brief Parse the record that corresponds to a LangOptions data 3960212795Sdim/// structure. 3961212795Sdim/// 3962212795Sdim/// This routine parses the language options from the AST file and then gives 3963212795Sdim/// them to the AST listener if one is set. 3964212795Sdim/// 3965212795Sdim/// \returns true if the listener deems the file unacceptable, false otherwise. 3966243830Sdimbool ASTReader::ParseLanguageOptions(const RecordData &Record, 3967243830Sdim bool Complain, 3968243830Sdim ASTReaderListener &Listener) { 3969243830Sdim LangOptions LangOpts; 3970243830Sdim unsigned Idx = 0; 3971226633Sdim#define LANGOPT(Name, Bits, Default, Description) \ 3972226633Sdim LangOpts.Name = Record[Idx++]; 3973226633Sdim#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 3974226633Sdim LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 3975226633Sdim#include "clang/Basic/LangOptions.def" 3976249423Sdim#define SANITIZER(NAME, ID) LangOpts.Sanitize.ID = Record[Idx++]; 3977249423Sdim#include "clang/Basic/Sanitizers.def" 3978239462Sdim 3979243830Sdim ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++]; 3980243830Sdim VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx); 3981243830Sdim LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion); 3982243830Sdim 3983243830Sdim unsigned Length = Record[Idx++]; 3984243830Sdim LangOpts.CurrentModule.assign(Record.begin() + Idx, 3985243830Sdim Record.begin() + Idx + Length); 3986249423Sdim 3987249423Sdim Idx += Length; 3988249423Sdim 3989249423Sdim // Comment options. 3990249423Sdim for (unsigned N = Record[Idx++]; N; --N) { 3991249423Sdim LangOpts.CommentOpts.BlockCommandNames.push_back( 3992249423Sdim ReadString(Record, Idx)); 3993249423Sdim } 3994251662Sdim LangOpts.CommentOpts.ParseAllComments = Record[Idx++]; 3995249423Sdim 3996243830Sdim return Listener.ReadLanguageOptions(LangOpts, Complain); 3997243830Sdim} 3998243830Sdim 3999243830Sdimbool ASTReader::ParseTargetOptions(const RecordData &Record, 4000243830Sdim bool Complain, 4001243830Sdim ASTReaderListener &Listener) { 4002243830Sdim unsigned Idx = 0; 4003243830Sdim TargetOptions TargetOpts; 4004243830Sdim TargetOpts.Triple = ReadString(Record, Idx); 4005243830Sdim TargetOpts.CPU = ReadString(Record, Idx); 4006243830Sdim TargetOpts.ABI = ReadString(Record, Idx); 4007243830Sdim TargetOpts.CXXABI = ReadString(Record, Idx); 4008243830Sdim TargetOpts.LinkerVersion = ReadString(Record, Idx); 4009243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4010243830Sdim TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx)); 4011212795Sdim } 4012243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4013243830Sdim TargetOpts.Features.push_back(ReadString(Record, Idx)); 4014243830Sdim } 4015212795Sdim 4016243830Sdim return Listener.ReadTargetOptions(TargetOpts, Complain); 4017212795Sdim} 4018212795Sdim 4019243830Sdimbool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain, 4020243830Sdim ASTReaderListener &Listener) { 4021243830Sdim DiagnosticOptions DiagOpts; 4022243830Sdim unsigned Idx = 0; 4023243830Sdim#define DIAGOPT(Name, Bits, Default) DiagOpts.Name = Record[Idx++]; 4024243830Sdim#define ENUM_DIAGOPT(Name, Type, Bits, Default) \ 4025243830Sdim DiagOpts.set##Name(static_cast<Type>(Record[Idx++])); 4026243830Sdim#include "clang/Basic/DiagnosticOptions.def" 4027243830Sdim 4028243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4029243830Sdim DiagOpts.Warnings.push_back(ReadString(Record, Idx)); 4030243830Sdim } 4031243830Sdim 4032243830Sdim return Listener.ReadDiagnosticOptions(DiagOpts, Complain); 4033243830Sdim} 4034243830Sdim 4035243830Sdimbool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain, 4036243830Sdim ASTReaderListener &Listener) { 4037243830Sdim FileSystemOptions FSOpts; 4038243830Sdim unsigned Idx = 0; 4039243830Sdim FSOpts.WorkingDir = ReadString(Record, Idx); 4040243830Sdim return Listener.ReadFileSystemOptions(FSOpts, Complain); 4041243830Sdim} 4042243830Sdim 4043243830Sdimbool ASTReader::ParseHeaderSearchOptions(const RecordData &Record, 4044243830Sdim bool Complain, 4045243830Sdim ASTReaderListener &Listener) { 4046243830Sdim HeaderSearchOptions HSOpts; 4047243830Sdim unsigned Idx = 0; 4048243830Sdim HSOpts.Sysroot = ReadString(Record, Idx); 4049243830Sdim 4050243830Sdim // Include entries. 4051243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4052243830Sdim std::string Path = ReadString(Record, Idx); 4053243830Sdim frontend::IncludeDirGroup Group 4054243830Sdim = static_cast<frontend::IncludeDirGroup>(Record[Idx++]); 4055243830Sdim bool IsFramework = Record[Idx++]; 4056243830Sdim bool IgnoreSysRoot = Record[Idx++]; 4057243830Sdim HSOpts.UserEntries.push_back( 4058249423Sdim HeaderSearchOptions::Entry(Path, Group, IsFramework, IgnoreSysRoot)); 4059243830Sdim } 4060243830Sdim 4061243830Sdim // System header prefixes. 4062243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4063243830Sdim std::string Prefix = ReadString(Record, Idx); 4064243830Sdim bool IsSystemHeader = Record[Idx++]; 4065243830Sdim HSOpts.SystemHeaderPrefixes.push_back( 4066243830Sdim HeaderSearchOptions::SystemHeaderPrefix(Prefix, IsSystemHeader)); 4067243830Sdim } 4068243830Sdim 4069243830Sdim HSOpts.ResourceDir = ReadString(Record, Idx); 4070243830Sdim HSOpts.ModuleCachePath = ReadString(Record, Idx); 4071243830Sdim HSOpts.DisableModuleHash = Record[Idx++]; 4072243830Sdim HSOpts.UseBuiltinIncludes = Record[Idx++]; 4073243830Sdim HSOpts.UseStandardSystemIncludes = Record[Idx++]; 4074243830Sdim HSOpts.UseStandardCXXIncludes = Record[Idx++]; 4075243830Sdim HSOpts.UseLibcxx = Record[Idx++]; 4076243830Sdim 4077243830Sdim return Listener.ReadHeaderSearchOptions(HSOpts, Complain); 4078243830Sdim} 4079243830Sdim 4080243830Sdimbool ASTReader::ParsePreprocessorOptions(const RecordData &Record, 4081243830Sdim bool Complain, 4082243830Sdim ASTReaderListener &Listener, 4083243830Sdim std::string &SuggestedPredefines) { 4084243830Sdim PreprocessorOptions PPOpts; 4085243830Sdim unsigned Idx = 0; 4086243830Sdim 4087243830Sdim // Macro definitions/undefs 4088243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4089243830Sdim std::string Macro = ReadString(Record, Idx); 4090243830Sdim bool IsUndef = Record[Idx++]; 4091243830Sdim PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef)); 4092243830Sdim } 4093243830Sdim 4094243830Sdim // Includes 4095243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4096243830Sdim PPOpts.Includes.push_back(ReadString(Record, Idx)); 4097243830Sdim } 4098243830Sdim 4099243830Sdim // Macro Includes 4100243830Sdim for (unsigned N = Record[Idx++]; N; --N) { 4101243830Sdim PPOpts.MacroIncludes.push_back(ReadString(Record, Idx)); 4102243830Sdim } 4103243830Sdim 4104243830Sdim PPOpts.UsePredefines = Record[Idx++]; 4105251662Sdim PPOpts.DetailedRecord = Record[Idx++]; 4106243830Sdim PPOpts.ImplicitPCHInclude = ReadString(Record, Idx); 4107243830Sdim PPOpts.ImplicitPTHInclude = ReadString(Record, Idx); 4108243830Sdim PPOpts.ObjCXXARCStandardLibrary = 4109243830Sdim static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]); 4110243830Sdim SuggestedPredefines.clear(); 4111243830Sdim return Listener.ReadPreprocessorOptions(PPOpts, Complain, 4112243830Sdim SuggestedPredefines); 4113243830Sdim} 4114243830Sdim 4115234353Sdimstd::pair<ModuleFile *, unsigned> 4116234353SdimASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) { 4117226633Sdim GlobalPreprocessedEntityMapType::iterator 4118234353Sdim I = GlobalPreprocessedEntityMap.find(GlobalIndex); 4119226633Sdim assert(I != GlobalPreprocessedEntityMap.end() && 4120226633Sdim "Corrupted global preprocessed entity map"); 4121234353Sdim ModuleFile *M = I->second; 4122234353Sdim unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID; 4123234353Sdim return std::make_pair(M, LocalIndex); 4124234353Sdim} 4125234353Sdim 4126243830Sdimstd::pair<PreprocessingRecord::iterator, PreprocessingRecord::iterator> 4127243830SdimASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const { 4128243830Sdim if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord()) 4129243830Sdim return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID, 4130243830Sdim Mod.NumPreprocessedEntities); 4131243830Sdim 4132243830Sdim return std::make_pair(PreprocessingRecord::iterator(), 4133243830Sdim PreprocessingRecord::iterator()); 4134243830Sdim} 4135243830Sdim 4136243830Sdimstd::pair<ASTReader::ModuleDeclIterator, ASTReader::ModuleDeclIterator> 4137243830SdimASTReader::getModuleFileLevelDecls(ModuleFile &Mod) { 4138243830Sdim return std::make_pair(ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls), 4139243830Sdim ModuleDeclIterator(this, &Mod, 4140243830Sdim Mod.FileSortedDecls + Mod.NumFileSortedDecls)); 4141243830Sdim} 4142243830Sdim 4143234353SdimPreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 4144234353Sdim PreprocessedEntityID PPID = Index+1; 4145234353Sdim std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 4146234353Sdim ModuleFile &M = *PPInfo.first; 4147234353Sdim unsigned LocalIndex = PPInfo.second; 4148226633Sdim const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 4149218893Sdim 4150249423Sdim if (!PP.getPreprocessingRecord()) { 4151249423Sdim Error("no preprocessing record"); 4152249423Sdim return 0; 4153249423Sdim } 4154249423Sdim 4155226633Sdim SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 4156226633Sdim M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 4157226633Sdim 4158249423Sdim llvm::BitstreamEntry Entry = 4159249423Sdim M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd); 4160249423Sdim if (Entry.Kind != llvm::BitstreamEntry::Record) 4161226633Sdim return 0; 4162212795Sdim 4163226633Sdim // Read the record. 4164226633Sdim SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 4165226633Sdim ReadSourceLocation(M, PPOffs.End)); 4166226633Sdim PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 4167249423Sdim StringRef Blob; 4168226633Sdim RecordData Record; 4169226633Sdim PreprocessorDetailRecordTypes RecType = 4170249423Sdim (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord( 4171249423Sdim Entry.ID, Record, &Blob); 4172226633Sdim switch (RecType) { 4173226633Sdim case PPD_MACRO_EXPANSION: { 4174226633Sdim bool isBuiltin = Record[0]; 4175226633Sdim IdentifierInfo *Name = 0; 4176226633Sdim MacroDefinition *Def = 0; 4177226633Sdim if (isBuiltin) 4178226633Sdim Name = getLocalIdentifier(M, Record[1]); 4179226633Sdim else { 4180226633Sdim PreprocessedEntityID 4181226633Sdim GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 4182226633Sdim Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 4183218893Sdim } 4184226633Sdim 4185226633Sdim MacroExpansion *ME; 4186226633Sdim if (isBuiltin) 4187226633Sdim ME = new (PPRec) MacroExpansion(Name, Range); 4188226633Sdim else 4189226633Sdim ME = new (PPRec) MacroExpansion(Def, Range); 4190226633Sdim 4191226633Sdim return ME; 4192226633Sdim } 4193226633Sdim 4194226633Sdim case PPD_MACRO_DEFINITION: { 4195226633Sdim // Decode the identifier info and then check again; if the macro is 4196226633Sdim // still defined and associated with the identifier, 4197226633Sdim IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 4198226633Sdim MacroDefinition *MD 4199226633Sdim = new (PPRec) MacroDefinition(II, Range); 4200226633Sdim 4201226633Sdim if (DeserializationListener) 4202226633Sdim DeserializationListener->MacroDefinitionRead(PPID, MD); 4203226633Sdim 4204226633Sdim return MD; 4205226633Sdim } 4206226633Sdim 4207226633Sdim case PPD_INCLUSION_DIRECTIVE: { 4208249423Sdim const char *FullFileNameStart = Blob.data() + Record[0]; 4209249423Sdim StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]); 4210234353Sdim const FileEntry *File = 0; 4211234353Sdim if (!FullFileName.empty()) 4212234353Sdim File = PP.getFileManager().getFile(FullFileName); 4213218893Sdim 4214226633Sdim // FIXME: Stable encoding 4215226633Sdim InclusionDirective::InclusionKind Kind 4216226633Sdim = static_cast<InclusionDirective::InclusionKind>(Record[2]); 4217226633Sdim InclusionDirective *ID 4218226633Sdim = new (PPRec) InclusionDirective(PPRec, Kind, 4219249423Sdim StringRef(Blob.data(), Record[0]), 4220243830Sdim Record[1], Record[3], 4221226633Sdim File, 4222226633Sdim Range); 4223226633Sdim return ID; 4224218893Sdim } 4225226633Sdim } 4226234353Sdim 4227234353Sdim llvm_unreachable("Invalid PreprocessorDetailRecordTypes"); 4228226633Sdim} 4229226633Sdim 4230226633Sdim/// \brief \arg SLocMapI points at a chunk of a module that contains no 4231226633Sdim/// preprocessed entities or the entities it contains are not the ones we are 4232226633Sdim/// looking for. Find the next module that contains entities and return the ID 4233226633Sdim/// of the first entry. 4234226633SdimPreprocessedEntityID ASTReader::findNextPreprocessedEntity( 4235226633Sdim GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 4236226633Sdim ++SLocMapI; 4237226633Sdim for (GlobalSLocOffsetMapType::const_iterator 4238226633Sdim EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 4239234353Sdim ModuleFile &M = *SLocMapI->second; 4240226633Sdim if (M.NumPreprocessedEntities) 4241243830Sdim return M.BasePreprocessedEntityID; 4242218893Sdim } 4243218893Sdim 4244226633Sdim return getTotalNumPreprocessedEntities(); 4245218893Sdim} 4246218893Sdim 4247226633Sdimnamespace { 4248226633Sdim 4249226633Sdimtemplate <unsigned PPEntityOffset::*PPLoc> 4250226633Sdimstruct PPEntityComp { 4251226633Sdim const ASTReader &Reader; 4252234353Sdim ModuleFile &M; 4253226633Sdim 4254234353Sdim PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { } 4255226633Sdim 4256226633Sdim bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 4257226633Sdim SourceLocation LHS = getLoc(L); 4258226633Sdim SourceLocation RHS = getLoc(R); 4259226633Sdim return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4260226633Sdim } 4261226633Sdim 4262226633Sdim bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 4263226633Sdim SourceLocation LHS = getLoc(L); 4264226633Sdim return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4265226633Sdim } 4266226633Sdim 4267226633Sdim bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 4268226633Sdim SourceLocation RHS = getLoc(R); 4269226633Sdim return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 4270226633Sdim } 4271226633Sdim 4272226633Sdim SourceLocation getLoc(const PPEntityOffset &PPE) const { 4273226633Sdim return Reader.ReadSourceLocation(M, PPE.*PPLoc); 4274226633Sdim } 4275226633Sdim}; 4276226633Sdim 4277226633Sdim} 4278226633Sdim 4279226633Sdim/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 4280226633SdimPreprocessedEntityID 4281226633SdimASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 4282226633Sdim if (SourceMgr.isLocalSourceLocation(BLoc)) 4283226633Sdim return getTotalNumPreprocessedEntities(); 4284226633Sdim 4285226633Sdim GlobalSLocOffsetMapType::const_iterator 4286226633Sdim SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4287249423Sdim BLoc.getOffset() - 1); 4288226633Sdim assert(SLocMapI != GlobalSLocOffsetMap.end() && 4289226633Sdim "Corrupted global sloc offset map"); 4290226633Sdim 4291226633Sdim if (SLocMapI->second->NumPreprocessedEntities == 0) 4292226633Sdim return findNextPreprocessedEntity(SLocMapI); 4293226633Sdim 4294234353Sdim ModuleFile &M = *SLocMapI->second; 4295226633Sdim typedef const PPEntityOffset *pp_iterator; 4296226633Sdim pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4297226633Sdim pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4298226633Sdim 4299226633Sdim size_t Count = M.NumPreprocessedEntities; 4300226633Sdim size_t Half; 4301226633Sdim pp_iterator First = pp_begin; 4302226633Sdim pp_iterator PPI; 4303226633Sdim 4304226633Sdim // Do a binary search manually instead of using std::lower_bound because 4305226633Sdim // The end locations of entities may be unordered (when a macro expansion 4306226633Sdim // is inside another macro argument), but for this case it is not important 4307226633Sdim // whether we get the first macro expansion or its containing macro. 4308226633Sdim while (Count > 0) { 4309226633Sdim Half = Count/2; 4310226633Sdim PPI = First; 4311226633Sdim std::advance(PPI, Half); 4312226633Sdim if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 4313226633Sdim BLoc)){ 4314226633Sdim First = PPI; 4315226633Sdim ++First; 4316226633Sdim Count = Count - Half - 1; 4317226633Sdim } else 4318226633Sdim Count = Half; 4319226633Sdim } 4320226633Sdim 4321226633Sdim if (PPI == pp_end) 4322226633Sdim return findNextPreprocessedEntity(SLocMapI); 4323226633Sdim 4324243830Sdim return M.BasePreprocessedEntityID + (PPI - pp_begin); 4325226633Sdim} 4326226633Sdim 4327226633Sdim/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 4328226633SdimPreprocessedEntityID 4329226633SdimASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 4330226633Sdim if (SourceMgr.isLocalSourceLocation(ELoc)) 4331226633Sdim return getTotalNumPreprocessedEntities(); 4332226633Sdim 4333226633Sdim GlobalSLocOffsetMapType::const_iterator 4334226633Sdim SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 4335249423Sdim ELoc.getOffset() - 1); 4336226633Sdim assert(SLocMapI != GlobalSLocOffsetMap.end() && 4337226633Sdim "Corrupted global sloc offset map"); 4338226633Sdim 4339226633Sdim if (SLocMapI->second->NumPreprocessedEntities == 0) 4340226633Sdim return findNextPreprocessedEntity(SLocMapI); 4341226633Sdim 4342234353Sdim ModuleFile &M = *SLocMapI->second; 4343226633Sdim typedef const PPEntityOffset *pp_iterator; 4344226633Sdim pp_iterator pp_begin = M.PreprocessedEntityOffsets; 4345226633Sdim pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 4346226633Sdim pp_iterator PPI = 4347226633Sdim std::upper_bound(pp_begin, pp_end, ELoc, 4348226633Sdim PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 4349226633Sdim 4350226633Sdim if (PPI == pp_end) 4351226633Sdim return findNextPreprocessedEntity(SLocMapI); 4352226633Sdim 4353243830Sdim return M.BasePreprocessedEntityID + (PPI - pp_begin); 4354226633Sdim} 4355226633Sdim 4356226633Sdim/// \brief Returns a pair of [Begin, End) indices of preallocated 4357226633Sdim/// preprocessed entities that \arg Range encompasses. 4358226633Sdimstd::pair<unsigned, unsigned> 4359226633Sdim ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 4360226633Sdim if (Range.isInvalid()) 4361226633Sdim return std::make_pair(0,0); 4362226633Sdim assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 4363226633Sdim 4364226633Sdim PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 4365226633Sdim PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 4366226633Sdim return std::make_pair(BeginID, EndID); 4367226633Sdim} 4368226633Sdim 4369234353Sdim/// \brief Optionally returns true or false if the preallocated preprocessed 4370234353Sdim/// entity with index \arg Index came from file \arg FID. 4371249423SdimOptional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index, 4372234353Sdim FileID FID) { 4373234353Sdim if (FID.isInvalid()) 4374234353Sdim return false; 4375234353Sdim 4376234353Sdim std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index); 4377234353Sdim ModuleFile &M = *PPInfo.first; 4378234353Sdim unsigned LocalIndex = PPInfo.second; 4379234353Sdim const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 4380234353Sdim 4381234353Sdim SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin); 4382234353Sdim if (Loc.isInvalid()) 4383234353Sdim return false; 4384234353Sdim 4385234353Sdim if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID)) 4386234353Sdim return true; 4387234353Sdim else 4388234353Sdim return false; 4389234353Sdim} 4390234353Sdim 4391226633Sdimnamespace { 4392226633Sdim /// \brief Visitor used to search for information about a header file. 4393226633Sdim class HeaderFileInfoVisitor { 4394226633Sdim const FileEntry *FE; 4395218893Sdim 4396249423Sdim Optional<HeaderFileInfo> HFI; 4397226633Sdim 4398226633Sdim public: 4399249423Sdim explicit HeaderFileInfoVisitor(const FileEntry *FE) 4400249423Sdim : FE(FE) { } 4401226633Sdim 4402234353Sdim static bool visit(ModuleFile &M, void *UserData) { 4403226633Sdim HeaderFileInfoVisitor *This 4404226633Sdim = static_cast<HeaderFileInfoVisitor *>(UserData); 4405226633Sdim 4406226633Sdim HeaderFileInfoLookupTable *Table 4407226633Sdim = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 4408226633Sdim if (!Table) 4409226633Sdim return false; 4410218893Sdim 4411226633Sdim // Look in the on-disk hash table for an entry for this file name. 4412249423Sdim HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE); 4413226633Sdim if (Pos == Table->end()) 4414226633Sdim return false; 4415226633Sdim 4416226633Sdim This->HFI = *Pos; 4417226633Sdim return true; 4418226633Sdim } 4419226633Sdim 4420249423Sdim Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 4421226633Sdim }; 4422226633Sdim} 4423226633Sdim 4424226633SdimHeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 4425249423Sdim HeaderFileInfoVisitor Visitor(FE); 4426226633Sdim ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 4427263508Sdim if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) 4428226633Sdim return *HFI; 4429218893Sdim 4430218893Sdim return HeaderFileInfo(); 4431218893Sdim} 4432218893Sdim 4433226633Sdimvoid ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 4434243830Sdim // FIXME: Make it work properly with modules. 4435249423Sdim SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates; 4436226633Sdim for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 4437234353Sdim ModuleFile &F = *(*I); 4438226633Sdim unsigned Idx = 0; 4439243830Sdim DiagStates.clear(); 4440243830Sdim assert(!Diag.DiagStates.empty()); 4441243830Sdim DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one. 4442226633Sdim while (Idx < F.PragmaDiagMappings.size()) { 4443226633Sdim SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 4444243830Sdim unsigned DiagStateID = F.PragmaDiagMappings[Idx++]; 4445243830Sdim if (DiagStateID != 0) { 4446243830Sdim Diag.DiagStatePoints.push_back( 4447243830Sdim DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1], 4448243830Sdim FullSourceLoc(Loc, SourceMgr))); 4449243830Sdim continue; 4450243830Sdim } 4451243830Sdim 4452243830Sdim assert(DiagStateID == 0); 4453243830Sdim // A new DiagState was created here. 4454234353Sdim Diag.DiagStates.push_back(*Diag.GetCurDiagState()); 4455243830Sdim DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back(); 4456243830Sdim DiagStates.push_back(NewState); 4457234353Sdim Diag.DiagStatePoints.push_back( 4458243830Sdim DiagnosticsEngine::DiagStatePoint(NewState, 4459234353Sdim FullSourceLoc(Loc, SourceMgr))); 4460226633Sdim while (1) { 4461226633Sdim assert(Idx < F.PragmaDiagMappings.size() && 4462226633Sdim "Invalid data, didn't find '-1' marking end of diag/map pairs"); 4463226633Sdim if (Idx >= F.PragmaDiagMappings.size()) { 4464226633Sdim break; // Something is messed up but at least avoid infinite loop in 4465226633Sdim // release build. 4466226633Sdim } 4467226633Sdim unsigned DiagID = F.PragmaDiagMappings[Idx++]; 4468226633Sdim if (DiagID == (unsigned)-1) { 4469226633Sdim break; // no more diag/map pairs for this location. 4470226633Sdim } 4471226633Sdim diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 4472234353Sdim DiagnosticMappingInfo MappingInfo = Diag.makeMappingInfo(Map, Loc); 4473234353Sdim Diag.GetCurDiagState()->setMappingInfo(DiagID, MappingInfo); 4474226633Sdim } 4475218893Sdim } 4476218893Sdim } 4477218893Sdim} 4478218893Sdim 4479212795Sdim/// \brief Get the correct cursor and offset for loading a type. 4480212795SdimASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 4481226633Sdim GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 4482226633Sdim assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 4483234353Sdim ModuleFile *M = I->second; 4484226633Sdim return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 4485212795Sdim} 4486212795Sdim 4487212795Sdim/// \brief Read and return the type with the given index.. 4488212795Sdim/// 4489212795Sdim/// The index is the type ID, shifted and minus the number of predefs. This 4490212795Sdim/// routine actually reads the record corresponding to the type at the given 4491212795Sdim/// location. It is a helper routine for GetType, which deals with reading type 4492212795Sdim/// IDs. 4493226633SdimQualType ASTReader::readTypeRecord(unsigned Index) { 4494212795Sdim RecordLocation Loc = TypeCursorForIndex(Index); 4495249423Sdim BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 4496212795Sdim 4497212795Sdim // Keep track of where we are in the stream, then jump back there 4498212795Sdim // after reading this type. 4499212795Sdim SavedStreamPosition SavedPosition(DeclsCursor); 4500212795Sdim 4501212795Sdim ReadingKindTracker ReadingKind(Read_Type, *this); 4502212795Sdim 4503212795Sdim // Note that we are loading a type record. 4504212795Sdim Deserializing AType(this); 4505212795Sdim 4506226633Sdim unsigned Idx = 0; 4507218893Sdim DeclsCursor.JumpToBit(Loc.Offset); 4508212795Sdim RecordData Record; 4509212795Sdim unsigned Code = DeclsCursor.ReadCode(); 4510249423Sdim switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) { 4511212795Sdim case TYPE_EXT_QUAL: { 4512212795Sdim if (Record.size() != 2) { 4513212795Sdim Error("Incorrect encoding of extended qualifier type"); 4514212795Sdim return QualType(); 4515212795Sdim } 4516226633Sdim QualType Base = readType(*Loc.F, Record, Idx); 4517226633Sdim Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 4518226633Sdim return Context.getQualifiedType(Base, Quals); 4519212795Sdim } 4520212795Sdim 4521212795Sdim case TYPE_COMPLEX: { 4522212795Sdim if (Record.size() != 1) { 4523212795Sdim Error("Incorrect encoding of complex type"); 4524212795Sdim return QualType(); 4525212795Sdim } 4526226633Sdim QualType ElemType = readType(*Loc.F, Record, Idx); 4527226633Sdim return Context.getComplexType(ElemType); 4528212795Sdim } 4529212795Sdim 4530212795Sdim case TYPE_POINTER: { 4531212795Sdim if (Record.size() != 1) { 4532212795Sdim Error("Incorrect encoding of pointer type"); 4533212795Sdim return QualType(); 4534212795Sdim } 4535226633Sdim QualType PointeeType = readType(*Loc.F, Record, Idx); 4536226633Sdim return Context.getPointerType(PointeeType); 4537212795Sdim } 4538212795Sdim 4539263508Sdim case TYPE_DECAYED: { 4540263508Sdim if (Record.size() != 1) { 4541263508Sdim Error("Incorrect encoding of decayed type"); 4542263508Sdim return QualType(); 4543263508Sdim } 4544263508Sdim QualType OriginalType = readType(*Loc.F, Record, Idx); 4545263508Sdim QualType DT = Context.getAdjustedParameterType(OriginalType); 4546263508Sdim if (!isa<DecayedType>(DT)) 4547263508Sdim Error("Decayed type does not decay"); 4548263508Sdim return DT; 4549263508Sdim } 4550263508Sdim 4551212795Sdim case TYPE_BLOCK_POINTER: { 4552212795Sdim if (Record.size() != 1) { 4553212795Sdim Error("Incorrect encoding of block pointer type"); 4554212795Sdim return QualType(); 4555212795Sdim } 4556226633Sdim QualType PointeeType = readType(*Loc.F, Record, Idx); 4557226633Sdim return Context.getBlockPointerType(PointeeType); 4558212795Sdim } 4559212795Sdim 4560212795Sdim case TYPE_LVALUE_REFERENCE: { 4561221345Sdim if (Record.size() != 2) { 4562212795Sdim Error("Incorrect encoding of lvalue reference type"); 4563212795Sdim return QualType(); 4564212795Sdim } 4565226633Sdim QualType PointeeType = readType(*Loc.F, Record, Idx); 4566226633Sdim return Context.getLValueReferenceType(PointeeType, Record[1]); 4567212795Sdim } 4568212795Sdim 4569212795Sdim case TYPE_RVALUE_REFERENCE: { 4570212795Sdim if (Record.size() != 1) { 4571212795Sdim Error("Incorrect encoding of rvalue reference type"); 4572212795Sdim return QualType(); 4573212795Sdim } 4574226633Sdim QualType PointeeType = readType(*Loc.F, Record, Idx); 4575226633Sdim return Context.getRValueReferenceType(PointeeType); 4576212795Sdim } 4577212795Sdim 4578212795Sdim case TYPE_MEMBER_POINTER: { 4579212795Sdim if (Record.size() != 2) { 4580212795Sdim Error("Incorrect encoding of member pointer type"); 4581212795Sdim return QualType(); 4582212795Sdim } 4583226633Sdim QualType PointeeType = readType(*Loc.F, Record, Idx); 4584226633Sdim QualType ClassType = readType(*Loc.F, Record, Idx); 4585218893Sdim if (PointeeType.isNull() || ClassType.isNull()) 4586218893Sdim return QualType(); 4587218893Sdim 4588226633Sdim return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 4589212795Sdim } 4590212795Sdim 4591212795Sdim case TYPE_CONSTANT_ARRAY: { 4592226633Sdim QualType ElementType = readType(*Loc.F, Record, Idx); 4593212795Sdim ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4594212795Sdim unsigned IndexTypeQuals = Record[2]; 4595212795Sdim unsigned Idx = 3; 4596212795Sdim llvm::APInt Size = ReadAPInt(Record, Idx); 4597226633Sdim return Context.getConstantArrayType(ElementType, Size, 4598212795Sdim ASM, IndexTypeQuals); 4599212795Sdim } 4600212795Sdim 4601212795Sdim case TYPE_INCOMPLETE_ARRAY: { 4602226633Sdim QualType ElementType = readType(*Loc.F, Record, Idx); 4603212795Sdim ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4604212795Sdim unsigned IndexTypeQuals = Record[2]; 4605226633Sdim return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 4606212795Sdim } 4607212795Sdim 4608212795Sdim case TYPE_VARIABLE_ARRAY: { 4609226633Sdim QualType ElementType = readType(*Loc.F, Record, Idx); 4610212795Sdim ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 4611212795Sdim unsigned IndexTypeQuals = Record[2]; 4612218893Sdim SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 4613218893Sdim SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 4614226633Sdim return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 4615212795Sdim ASM, IndexTypeQuals, 4616212795Sdim SourceRange(LBLoc, RBLoc)); 4617212795Sdim } 4618212795Sdim 4619212795Sdim case TYPE_VECTOR: { 4620212795Sdim if (Record.size() != 3) { 4621212795Sdim Error("incorrect encoding of vector type in AST file"); 4622212795Sdim return QualType(); 4623212795Sdim } 4624212795Sdim 4625226633Sdim QualType ElementType = readType(*Loc.F, Record, Idx); 4626212795Sdim unsigned NumElements = Record[1]; 4627218893Sdim unsigned VecKind = Record[2]; 4628226633Sdim return Context.getVectorType(ElementType, NumElements, 4629218893Sdim (VectorType::VectorKind)VecKind); 4630212795Sdim } 4631212795Sdim 4632212795Sdim case TYPE_EXT_VECTOR: { 4633212795Sdim if (Record.size() != 3) { 4634212795Sdim Error("incorrect encoding of extended vector type in AST file"); 4635212795Sdim return QualType(); 4636212795Sdim } 4637212795Sdim 4638226633Sdim QualType ElementType = readType(*Loc.F, Record, Idx); 4639212795Sdim unsigned NumElements = Record[1]; 4640226633Sdim return Context.getExtVectorType(ElementType, NumElements); 4641212795Sdim } 4642212795Sdim 4643212795Sdim case TYPE_FUNCTION_NO_PROTO: { 4644224145Sdim if (Record.size() != 6) { 4645212795Sdim Error("incorrect encoding of no-proto function type"); 4646212795Sdim return QualType(); 4647212795Sdim } 4648226633Sdim QualType ResultType = readType(*Loc.F, Record, Idx); 4649224145Sdim FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 4650224145Sdim (CallingConv)Record[4], Record[5]); 4651226633Sdim return Context.getFunctionNoProtoType(ResultType, Info); 4652212795Sdim } 4653212795Sdim 4654212795Sdim case TYPE_FUNCTION_PROTO: { 4655226633Sdim QualType ResultType = readType(*Loc.F, Record, Idx); 4656218893Sdim 4657218893Sdim FunctionProtoType::ExtProtoInfo EPI; 4658218893Sdim EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 4659221345Sdim /*hasregparm*/ Record[2], 4660221345Sdim /*regparm*/ Record[3], 4661224145Sdim static_cast<CallingConv>(Record[4]), 4662224145Sdim /*produces*/ Record[5]); 4663218893Sdim 4664224145Sdim unsigned Idx = 6; 4665212795Sdim unsigned NumParams = Record[Idx++]; 4666226633Sdim SmallVector<QualType, 16> ParamTypes; 4667212795Sdim for (unsigned I = 0; I != NumParams; ++I) 4668226633Sdim ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 4669218893Sdim 4670218893Sdim EPI.Variadic = Record[Idx++]; 4671234353Sdim EPI.HasTrailingReturn = Record[Idx++]; 4672218893Sdim EPI.TypeQuals = Record[Idx++]; 4673218893Sdim EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 4674221345Sdim ExceptionSpecificationType EST = 4675221345Sdim static_cast<ExceptionSpecificationType>(Record[Idx++]); 4676221345Sdim EPI.ExceptionSpecType = EST; 4677234353Sdim SmallVector<QualType, 2> Exceptions; 4678221345Sdim if (EST == EST_Dynamic) { 4679221345Sdim EPI.NumExceptions = Record[Idx++]; 4680221345Sdim for (unsigned I = 0; I != EPI.NumExceptions; ++I) 4681226633Sdim Exceptions.push_back(readType(*Loc.F, Record, Idx)); 4682221345Sdim EPI.Exceptions = Exceptions.data(); 4683221345Sdim } else if (EST == EST_ComputedNoexcept) { 4684221345Sdim EPI.NoexceptExpr = ReadExpr(*Loc.F); 4685235864Sdim } else if (EST == EST_Uninstantiated) { 4686235864Sdim EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4687235864Sdim EPI.ExceptionSpecTemplate = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4688239462Sdim } else if (EST == EST_Unevaluated) { 4689239462Sdim EPI.ExceptionSpecDecl = ReadDeclAs<FunctionDecl>(*Loc.F, Record, Idx); 4690221345Sdim } 4691249423Sdim return Context.getFunctionType(ResultType, ParamTypes, EPI); 4692212795Sdim } 4693212795Sdim 4694226633Sdim case TYPE_UNRESOLVED_USING: { 4695226633Sdim unsigned Idx = 0; 4696226633Sdim return Context.getTypeDeclType( 4697226633Sdim ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 4698226633Sdim } 4699226633Sdim 4700212795Sdim case TYPE_TYPEDEF: { 4701212795Sdim if (Record.size() != 2) { 4702212795Sdim Error("incorrect encoding of typedef type"); 4703212795Sdim return QualType(); 4704212795Sdim } 4705226633Sdim unsigned Idx = 0; 4706226633Sdim TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 4707226633Sdim QualType Canonical = readType(*Loc.F, Record, Idx); 4708218893Sdim if (!Canonical.isNull()) 4709226633Sdim Canonical = Context.getCanonicalType(Canonical); 4710226633Sdim return Context.getTypedefType(Decl, Canonical); 4711212795Sdim } 4712212795Sdim 4713212795Sdim case TYPE_TYPEOF_EXPR: 4714226633Sdim return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 4715212795Sdim 4716212795Sdim case TYPE_TYPEOF: { 4717212795Sdim if (Record.size() != 1) { 4718212795Sdim Error("incorrect encoding of typeof(type) in AST file"); 4719212795Sdim return QualType(); 4720212795Sdim } 4721226633Sdim QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4722226633Sdim return Context.getTypeOfType(UnderlyingType); 4723212795Sdim } 4724212795Sdim 4725234353Sdim case TYPE_DECLTYPE: { 4726234353Sdim QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4727234353Sdim return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType); 4728234353Sdim } 4729212795Sdim 4730223017Sdim case TYPE_UNARY_TRANSFORM: { 4731226633Sdim QualType BaseType = readType(*Loc.F, Record, Idx); 4732226633Sdim QualType UnderlyingType = readType(*Loc.F, Record, Idx); 4733223017Sdim UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 4734226633Sdim return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 4735223017Sdim } 4736223017Sdim 4737251662Sdim case TYPE_AUTO: { 4738251662Sdim QualType Deduced = readType(*Loc.F, Record, Idx); 4739251662Sdim bool IsDecltypeAuto = Record[Idx++]; 4740251662Sdim bool IsDependent = Deduced.isNull() ? Record[Idx++] : false; 4741251662Sdim return Context.getAutoType(Deduced, IsDecltypeAuto, IsDependent); 4742251662Sdim } 4743218893Sdim 4744212795Sdim case TYPE_RECORD: { 4745212795Sdim if (Record.size() != 2) { 4746212795Sdim Error("incorrect encoding of record type"); 4747212795Sdim return QualType(); 4748212795Sdim } 4749226633Sdim unsigned Idx = 0; 4750226633Sdim bool IsDependent = Record[Idx++]; 4751234353Sdim RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx); 4752234353Sdim RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl()); 4753234353Sdim QualType T = Context.getRecordType(RD); 4754218893Sdim const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4755212795Sdim return T; 4756212795Sdim } 4757212795Sdim 4758212795Sdim case TYPE_ENUM: { 4759212795Sdim if (Record.size() != 2) { 4760212795Sdim Error("incorrect encoding of enum type"); 4761212795Sdim return QualType(); 4762212795Sdim } 4763226633Sdim unsigned Idx = 0; 4764226633Sdim bool IsDependent = Record[Idx++]; 4765226633Sdim QualType T 4766226633Sdim = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 4767218893Sdim const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4768212795Sdim return T; 4769212795Sdim } 4770212795Sdim 4771218893Sdim case TYPE_ATTRIBUTED: { 4772218893Sdim if (Record.size() != 3) { 4773218893Sdim Error("incorrect encoding of attributed type"); 4774218893Sdim return QualType(); 4775218893Sdim } 4776226633Sdim QualType modifiedType = readType(*Loc.F, Record, Idx); 4777226633Sdim QualType equivalentType = readType(*Loc.F, Record, Idx); 4778218893Sdim AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 4779226633Sdim return Context.getAttributedType(kind, modifiedType, equivalentType); 4780218893Sdim } 4781218893Sdim 4782218893Sdim case TYPE_PAREN: { 4783218893Sdim if (Record.size() != 1) { 4784218893Sdim Error("incorrect encoding of paren type"); 4785218893Sdim return QualType(); 4786218893Sdim } 4787226633Sdim QualType InnerType = readType(*Loc.F, Record, Idx); 4788226633Sdim return Context.getParenType(InnerType); 4789218893Sdim } 4790218893Sdim 4791218893Sdim case TYPE_PACK_EXPANSION: { 4792218893Sdim if (Record.size() != 2) { 4793218893Sdim Error("incorrect encoding of pack expansion type"); 4794218893Sdim return QualType(); 4795218893Sdim } 4796226633Sdim QualType Pattern = readType(*Loc.F, Record, Idx); 4797218893Sdim if (Pattern.isNull()) 4798218893Sdim return QualType(); 4799249423Sdim Optional<unsigned> NumExpansions; 4800218893Sdim if (Record[1]) 4801218893Sdim NumExpansions = Record[1] - 1; 4802226633Sdim return Context.getPackExpansionType(Pattern, NumExpansions); 4803218893Sdim } 4804218893Sdim 4805212795Sdim case TYPE_ELABORATED: { 4806212795Sdim unsigned Idx = 0; 4807212795Sdim ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4808226633Sdim NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4809226633Sdim QualType NamedType = readType(*Loc.F, Record, Idx); 4810226633Sdim return Context.getElaboratedType(Keyword, NNS, NamedType); 4811212795Sdim } 4812212795Sdim 4813212795Sdim case TYPE_OBJC_INTERFACE: { 4814212795Sdim unsigned Idx = 0; 4815226633Sdim ObjCInterfaceDecl *ItfD 4816226633Sdim = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 4817234353Sdim return Context.getObjCInterfaceType(ItfD->getCanonicalDecl()); 4818212795Sdim } 4819212795Sdim 4820212795Sdim case TYPE_OBJC_OBJECT: { 4821212795Sdim unsigned Idx = 0; 4822226633Sdim QualType Base = readType(*Loc.F, Record, Idx); 4823212795Sdim unsigned NumProtos = Record[Idx++]; 4824226633Sdim SmallVector<ObjCProtocolDecl*, 4> Protos; 4825212795Sdim for (unsigned I = 0; I != NumProtos; ++I) 4826226633Sdim Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 4827226633Sdim return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 4828212795Sdim } 4829212795Sdim 4830212795Sdim case TYPE_OBJC_OBJECT_POINTER: { 4831212795Sdim unsigned Idx = 0; 4832226633Sdim QualType Pointee = readType(*Loc.F, Record, Idx); 4833226633Sdim return Context.getObjCObjectPointerType(Pointee); 4834212795Sdim } 4835212795Sdim 4836212795Sdim case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 4837212795Sdim unsigned Idx = 0; 4838226633Sdim QualType Parm = readType(*Loc.F, Record, Idx); 4839226633Sdim QualType Replacement = readType(*Loc.F, Record, Idx); 4840212795Sdim return 4841226633Sdim Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 4842212795Sdim Replacement); 4843212795Sdim } 4844212795Sdim 4845218893Sdim case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 4846218893Sdim unsigned Idx = 0; 4847226633Sdim QualType Parm = readType(*Loc.F, Record, Idx); 4848218893Sdim TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 4849226633Sdim return Context.getSubstTemplateTypeParmPackType( 4850218893Sdim cast<TemplateTypeParmType>(Parm), 4851218893Sdim ArgPack); 4852218893Sdim } 4853218893Sdim 4854212795Sdim case TYPE_INJECTED_CLASS_NAME: { 4855226633Sdim CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 4856226633Sdim QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 4857212795Sdim // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 4858212795Sdim // for AST reading, too much interdependencies. 4859212795Sdim return 4860226633Sdim QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 4861212795Sdim } 4862218893Sdim 4863212795Sdim case TYPE_TEMPLATE_TYPE_PARM: { 4864212795Sdim unsigned Idx = 0; 4865212795Sdim unsigned Depth = Record[Idx++]; 4866212795Sdim unsigned Index = Record[Idx++]; 4867212795Sdim bool Pack = Record[Idx++]; 4868226633Sdim TemplateTypeParmDecl *D 4869226633Sdim = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 4870226633Sdim return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 4871212795Sdim } 4872218893Sdim 4873212795Sdim case TYPE_DEPENDENT_NAME: { 4874212795Sdim unsigned Idx = 0; 4875212795Sdim ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4876226633Sdim NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4877226633Sdim const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4878226633Sdim QualType Canon = readType(*Loc.F, Record, Idx); 4879218893Sdim if (!Canon.isNull()) 4880226633Sdim Canon = Context.getCanonicalType(Canon); 4881226633Sdim return Context.getDependentNameType(Keyword, NNS, Name, Canon); 4882212795Sdim } 4883218893Sdim 4884212795Sdim case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 4885212795Sdim unsigned Idx = 0; 4886212795Sdim ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 4887226633Sdim NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 4888226633Sdim const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 4889212795Sdim unsigned NumArgs = Record[Idx++]; 4890226633Sdim SmallVector<TemplateArgument, 8> Args; 4891212795Sdim Args.reserve(NumArgs); 4892212795Sdim while (NumArgs--) 4893218893Sdim Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 4894226633Sdim return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 4895212795Sdim Args.size(), Args.data()); 4896212795Sdim } 4897218893Sdim 4898212795Sdim case TYPE_DEPENDENT_SIZED_ARRAY: { 4899212795Sdim unsigned Idx = 0; 4900212795Sdim 4901212795Sdim // ArrayType 4902226633Sdim QualType ElementType = readType(*Loc.F, Record, Idx); 4903212795Sdim ArrayType::ArraySizeModifier ASM 4904212795Sdim = (ArrayType::ArraySizeModifier)Record[Idx++]; 4905212795Sdim unsigned IndexTypeQuals = Record[Idx++]; 4906212795Sdim 4907212795Sdim // DependentSizedArrayType 4908218893Sdim Expr *NumElts = ReadExpr(*Loc.F); 4909218893Sdim SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 4910212795Sdim 4911226633Sdim return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 4912212795Sdim IndexTypeQuals, Brackets); 4913212795Sdim } 4914212795Sdim 4915212795Sdim case TYPE_TEMPLATE_SPECIALIZATION: { 4916212795Sdim unsigned Idx = 0; 4917212795Sdim bool IsDependent = Record[Idx++]; 4918218893Sdim TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 4919226633Sdim SmallVector<TemplateArgument, 8> Args; 4920218893Sdim ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 4921226633Sdim QualType Underlying = readType(*Loc.F, Record, Idx); 4922212795Sdim QualType T; 4923223017Sdim if (Underlying.isNull()) 4924226633Sdim T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 4925212795Sdim Args.size()); 4926212795Sdim else 4927226633Sdim T = Context.getTemplateSpecializationType(Name, Args.data(), 4928223017Sdim Args.size(), Underlying); 4929218893Sdim const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 4930212795Sdim return T; 4931212795Sdim } 4932226633Sdim 4933226633Sdim case TYPE_ATOMIC: { 4934226633Sdim if (Record.size() != 1) { 4935226633Sdim Error("Incorrect encoding of atomic type"); 4936226633Sdim return QualType(); 4937226633Sdim } 4938226633Sdim QualType ValueType = readType(*Loc.F, Record, Idx); 4939226633Sdim return Context.getAtomicType(ValueType); 4940212795Sdim } 4941226633Sdim } 4942234353Sdim llvm_unreachable("Invalid TypeCode!"); 4943212795Sdim} 4944212795Sdim 4945218893Sdimclass clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 4946212795Sdim ASTReader &Reader; 4947234353Sdim ModuleFile &F; 4948212795Sdim const ASTReader::RecordData &Record; 4949212795Sdim unsigned &Idx; 4950212795Sdim 4951218893Sdim SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 4952218893Sdim unsigned &I) { 4953218893Sdim return Reader.ReadSourceLocation(F, R, I); 4954218893Sdim } 4955218893Sdim 4956226633Sdim template<typename T> 4957226633Sdim T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 4958226633Sdim return Reader.ReadDeclAs<T>(F, Record, Idx); 4959226633Sdim } 4960226633Sdim 4961212795Sdimpublic: 4962234353Sdim TypeLocReader(ASTReader &Reader, ModuleFile &F, 4963212795Sdim const ASTReader::RecordData &Record, unsigned &Idx) 4964239462Sdim : Reader(Reader), F(F), Record(Record), Idx(Idx) 4965218893Sdim { } 4966212795Sdim 4967212795Sdim // We want compile-time assurance that we've enumerated all of 4968212795Sdim // these, so unfortunately we have to declare them first, then 4969212795Sdim // define them out-of-line. 4970212795Sdim#define ABSTRACT_TYPELOC(CLASS, PARENT) 4971212795Sdim#define TYPELOC(CLASS, PARENT) \ 4972212795Sdim void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 4973212795Sdim#include "clang/AST/TypeLocNodes.def" 4974212795Sdim 4975212795Sdim void VisitFunctionTypeLoc(FunctionTypeLoc); 4976212795Sdim void VisitArrayTypeLoc(ArrayTypeLoc); 4977212795Sdim}; 4978212795Sdim 4979212795Sdimvoid TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4980212795Sdim // nothing to do 4981212795Sdim} 4982212795Sdimvoid TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4983218893Sdim TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 4984212795Sdim if (TL.needsExtraLocalData()) { 4985212795Sdim TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 4986212795Sdim TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 4987212795Sdim TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 4988212795Sdim TL.setModeAttr(Record[Idx++]); 4989212795Sdim } 4990212795Sdim} 4991212795Sdimvoid TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 4992218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 4993212795Sdim} 4994212795Sdimvoid TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 4995218893Sdim TL.setStarLoc(ReadSourceLocation(Record, Idx)); 4996212795Sdim} 4997263508Sdimvoid TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) { 4998263508Sdim // nothing to do 4999263508Sdim} 5000212795Sdimvoid TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 5001218893Sdim TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 5002212795Sdim} 5003212795Sdimvoid TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 5004218893Sdim TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 5005212795Sdim} 5006212795Sdimvoid TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 5007218893Sdim TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 5008212795Sdim} 5009212795Sdimvoid TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 5010218893Sdim TL.setStarLoc(ReadSourceLocation(Record, Idx)); 5011221345Sdim TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 5012212795Sdim} 5013212795Sdimvoid TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 5014218893Sdim TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 5015218893Sdim TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 5016212795Sdim if (Record[Idx++]) 5017218893Sdim TL.setSizeExpr(Reader.ReadExpr(F)); 5018212795Sdim else 5019212795Sdim TL.setSizeExpr(0); 5020212795Sdim} 5021212795Sdimvoid TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 5022212795Sdim VisitArrayTypeLoc(TL); 5023212795Sdim} 5024212795Sdimvoid TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 5025212795Sdim VisitArrayTypeLoc(TL); 5026212795Sdim} 5027212795Sdimvoid TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 5028212795Sdim VisitArrayTypeLoc(TL); 5029212795Sdim} 5030212795Sdimvoid TypeLocReader::VisitDependentSizedArrayTypeLoc( 5031212795Sdim DependentSizedArrayTypeLoc TL) { 5032212795Sdim VisitArrayTypeLoc(TL); 5033212795Sdim} 5034212795Sdimvoid TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 5035212795Sdim DependentSizedExtVectorTypeLoc TL) { 5036218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5037212795Sdim} 5038212795Sdimvoid TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 5039218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5040212795Sdim} 5041212795Sdimvoid TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 5042218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5043212795Sdim} 5044212795Sdimvoid TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 5045221345Sdim TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 5046243830Sdim TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5047243830Sdim TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5048221345Sdim TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 5049212795Sdim for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 5050226633Sdim TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 5051212795Sdim } 5052212795Sdim} 5053212795Sdimvoid TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 5054212795Sdim VisitFunctionTypeLoc(TL); 5055212795Sdim} 5056212795Sdimvoid TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 5057212795Sdim VisitFunctionTypeLoc(TL); 5058212795Sdim} 5059212795Sdimvoid TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 5060218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5061212795Sdim} 5062212795Sdimvoid TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 5063218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5064212795Sdim} 5065212795Sdimvoid TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 5066218893Sdim TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 5067218893Sdim TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5068218893Sdim TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5069212795Sdim} 5070212795Sdimvoid TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 5071218893Sdim TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 5072218893Sdim TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5073218893Sdim TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5074218893Sdim TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 5075212795Sdim} 5076212795Sdimvoid TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 5077218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5078212795Sdim} 5079223017Sdimvoid TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 5080223017Sdim TL.setKWLoc(ReadSourceLocation(Record, Idx)); 5081223017Sdim TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5082223017Sdim TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5083223017Sdim TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 5084223017Sdim} 5085218893Sdimvoid TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 5086218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5087218893Sdim} 5088212795Sdimvoid TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 5089218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5090212795Sdim} 5091212795Sdimvoid TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 5092218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5093212795Sdim} 5094218893Sdimvoid TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 5095218893Sdim TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 5096218893Sdim if (TL.hasAttrOperand()) { 5097218893Sdim SourceRange range; 5098218893Sdim range.setBegin(ReadSourceLocation(Record, Idx)); 5099218893Sdim range.setEnd(ReadSourceLocation(Record, Idx)); 5100218893Sdim TL.setAttrOperandParensRange(range); 5101218893Sdim } 5102218893Sdim if (TL.hasAttrExprOperand()) { 5103218893Sdim if (Record[Idx++]) 5104218893Sdim TL.setAttrExprOperand(Reader.ReadExpr(F)); 5105218893Sdim else 5106218893Sdim TL.setAttrExprOperand(0); 5107218893Sdim } else if (TL.hasAttrEnumOperand()) 5108218893Sdim TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 5109218893Sdim} 5110212795Sdimvoid TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 5111218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5112212795Sdim} 5113212795Sdimvoid TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 5114212795Sdim SubstTemplateTypeParmTypeLoc TL) { 5115218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5116212795Sdim} 5117218893Sdimvoid TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 5118218893Sdim SubstTemplateTypeParmPackTypeLoc TL) { 5119218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5120218893Sdim} 5121212795Sdimvoid TypeLocReader::VisitTemplateSpecializationTypeLoc( 5122212795Sdim TemplateSpecializationTypeLoc TL) { 5123234353Sdim TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 5124218893Sdim TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 5125218893Sdim TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 5126218893Sdim TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 5127212795Sdim for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 5128212795Sdim TL.setArgLocInfo(i, 5129218893Sdim Reader.GetTemplateArgumentLocInfo(F, 5130218893Sdim TL.getTypePtr()->getArg(i).getKind(), 5131218893Sdim Record, Idx)); 5132212795Sdim} 5133218893Sdimvoid TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 5134218893Sdim TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5135218893Sdim TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5136218893Sdim} 5137212795Sdimvoid TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 5138234353Sdim TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 5139221345Sdim TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 5140212795Sdim} 5141212795Sdimvoid TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 5142218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5143212795Sdim} 5144212795Sdimvoid TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 5145234353Sdim TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 5146221345Sdim TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 5147218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5148212795Sdim} 5149212795Sdimvoid TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 5150212795Sdim DependentTemplateSpecializationTypeLoc TL) { 5151234353Sdim TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx)); 5152221345Sdim TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 5153234353Sdim TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx)); 5154234353Sdim TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 5155218893Sdim TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 5156218893Sdim TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 5157212795Sdim for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 5158212795Sdim TL.setArgLocInfo(I, 5159218893Sdim Reader.GetTemplateArgumentLocInfo(F, 5160218893Sdim TL.getTypePtr()->getArg(I).getKind(), 5161218893Sdim Record, Idx)); 5162212795Sdim} 5163218893Sdimvoid TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 5164218893Sdim TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 5165218893Sdim} 5166212795Sdimvoid TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 5167218893Sdim TL.setNameLoc(ReadSourceLocation(Record, Idx)); 5168212795Sdim} 5169212795Sdimvoid TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 5170212795Sdim TL.setHasBaseTypeAsWritten(Record[Idx++]); 5171218893Sdim TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 5172218893Sdim TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 5173212795Sdim for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 5174218893Sdim TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 5175212795Sdim} 5176212795Sdimvoid TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 5177218893Sdim TL.setStarLoc(ReadSourceLocation(Record, Idx)); 5178212795Sdim} 5179226633Sdimvoid TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) { 5180226633Sdim TL.setKWLoc(ReadSourceLocation(Record, Idx)); 5181226633Sdim TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 5182226633Sdim TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 5183226633Sdim} 5184212795Sdim 5185234353SdimTypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F, 5186212795Sdim const RecordData &Record, 5187212795Sdim unsigned &Idx) { 5188226633Sdim QualType InfoTy = readType(F, Record, Idx); 5189212795Sdim if (InfoTy.isNull()) 5190212795Sdim return 0; 5191212795Sdim 5192226633Sdim TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 5193218893Sdim TypeLocReader TLR(*this, F, Record, Idx); 5194212795Sdim for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 5195212795Sdim TLR.Visit(TL); 5196212795Sdim return TInfo; 5197212795Sdim} 5198212795Sdim 5199212795SdimQualType ASTReader::GetType(TypeID ID) { 5200212795Sdim unsigned FastQuals = ID & Qualifiers::FastMask; 5201212795Sdim unsigned Index = ID >> Qualifiers::FastWidth; 5202212795Sdim 5203212795Sdim if (Index < NUM_PREDEF_TYPE_IDS) { 5204212795Sdim QualType T; 5205212795Sdim switch ((PredefinedTypeIDs)Index) { 5206212795Sdim case PREDEF_TYPE_NULL_ID: return QualType(); 5207226633Sdim case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 5208226633Sdim case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 5209212795Sdim 5210212795Sdim case PREDEF_TYPE_CHAR_U_ID: 5211212795Sdim case PREDEF_TYPE_CHAR_S_ID: 5212212795Sdim // FIXME: Check that the signedness of CharTy is correct! 5213226633Sdim T = Context.CharTy; 5214212795Sdim break; 5215212795Sdim 5216226633Sdim case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 5217226633Sdim case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 5218226633Sdim case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 5219226633Sdim case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 5220226633Sdim case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 5221226633Sdim case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 5222226633Sdim case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 5223226633Sdim case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 5224226633Sdim case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 5225226633Sdim case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 5226226633Sdim case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 5227226633Sdim case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 5228226633Sdim case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 5229226633Sdim case PREDEF_TYPE_HALF_ID: T = Context.HalfTy; break; 5230226633Sdim case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 5231226633Sdim case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 5232226633Sdim case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 5233226633Sdim case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 5234226633Sdim case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 5235234353Sdim case PREDEF_TYPE_PSEUDO_OBJECT: T = Context.PseudoObjectTy; break; 5236226633Sdim case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 5237226633Sdim case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 5238226633Sdim case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 5239226633Sdim case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 5240226633Sdim case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 5241226633Sdim case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 5242226633Sdim case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 5243226633Sdim case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 5244249423Sdim case PREDEF_TYPE_IMAGE1D_ID: T = Context.OCLImage1dTy; break; 5245249423Sdim case PREDEF_TYPE_IMAGE1D_ARR_ID: T = Context.OCLImage1dArrayTy; break; 5246249423Sdim case PREDEF_TYPE_IMAGE1D_BUFF_ID: T = Context.OCLImage1dBufferTy; break; 5247249423Sdim case PREDEF_TYPE_IMAGE2D_ID: T = Context.OCLImage2dTy; break; 5248249423Sdim case PREDEF_TYPE_IMAGE2D_ARR_ID: T = Context.OCLImage2dArrayTy; break; 5249249423Sdim case PREDEF_TYPE_IMAGE3D_ID: T = Context.OCLImage3dTy; break; 5250249423Sdim case PREDEF_TYPE_SAMPLER_ID: T = Context.OCLSamplerTy; break; 5251249423Sdim case PREDEF_TYPE_EVENT_ID: T = Context.OCLEventTy; break; 5252226633Sdim case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 5253226633Sdim 5254226633Sdim case PREDEF_TYPE_AUTO_RREF_DEDUCT: 5255226633Sdim T = Context.getAutoRRefDeductType(); 5256226633Sdim break; 5257234353Sdim 5258234353Sdim case PREDEF_TYPE_ARC_UNBRIDGED_CAST: 5259234353Sdim T = Context.ARCUnbridgedCastTy; 5260234353Sdim break; 5261234353Sdim 5262239462Sdim case PREDEF_TYPE_VA_LIST_TAG: 5263239462Sdim T = Context.getVaListTagType(); 5264239462Sdim break; 5265243830Sdim 5266243830Sdim case PREDEF_TYPE_BUILTIN_FN: 5267243830Sdim T = Context.BuiltinFnTy; 5268243830Sdim break; 5269212795Sdim } 5270212795Sdim 5271212795Sdim assert(!T.isNull() && "Unknown predefined type"); 5272212795Sdim return T.withFastQualifiers(FastQuals); 5273212795Sdim } 5274212795Sdim 5275212795Sdim Index -= NUM_PREDEF_TYPE_IDS; 5276212795Sdim assert(Index < TypesLoaded.size() && "Type index out-of-range"); 5277212795Sdim if (TypesLoaded[Index].isNull()) { 5278226633Sdim TypesLoaded[Index] = readTypeRecord(Index); 5279218893Sdim if (TypesLoaded[Index].isNull()) 5280218893Sdim return QualType(); 5281218893Sdim 5282212795Sdim TypesLoaded[Index]->setFromAST(); 5283212795Sdim if (DeserializationListener) 5284212795Sdim DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 5285212795Sdim TypesLoaded[Index]); 5286212795Sdim } 5287212795Sdim 5288212795Sdim return TypesLoaded[Index].withFastQualifiers(FastQuals); 5289212795Sdim} 5290212795Sdim 5291234353SdimQualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) { 5292226633Sdim return GetType(getGlobalTypeID(F, LocalID)); 5293212795Sdim} 5294212795Sdim 5295226633Sdimserialization::TypeID 5296234353SdimASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const { 5297226633Sdim unsigned FastQuals = LocalID & Qualifiers::FastMask; 5298226633Sdim unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 5299226633Sdim 5300226633Sdim if (LocalIndex < NUM_PREDEF_TYPE_IDS) 5301226633Sdim return LocalID; 5302212795Sdim 5303226633Sdim ContinuousRangeMap<uint32_t, int, 2>::iterator I 5304226633Sdim = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 5305226633Sdim assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 5306218893Sdim 5307226633Sdim unsigned GlobalIndex = LocalIndex + I->second; 5308226633Sdim return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 5309218893Sdim} 5310218893Sdim 5311212795SdimTemplateArgumentLocInfo 5312234353SdimASTReader::GetTemplateArgumentLocInfo(ModuleFile &F, 5313218893Sdim TemplateArgument::ArgKind Kind, 5314212795Sdim const RecordData &Record, 5315212795Sdim unsigned &Index) { 5316212795Sdim switch (Kind) { 5317212795Sdim case TemplateArgument::Expression: 5318218893Sdim return ReadExpr(F); 5319212795Sdim case TemplateArgument::Type: 5320218893Sdim return GetTypeSourceInfo(F, Record, Index); 5321212795Sdim case TemplateArgument::Template: { 5322221345Sdim NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5323221345Sdim Index); 5324218893Sdim SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5325221345Sdim return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5326218893Sdim SourceLocation()); 5327212795Sdim } 5328218893Sdim case TemplateArgument::TemplateExpansion: { 5329221345Sdim NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 5330221345Sdim Index); 5331218893Sdim SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 5332218893Sdim SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 5333221345Sdim return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 5334218893Sdim EllipsisLoc); 5335218893Sdim } 5336212795Sdim case TemplateArgument::Null: 5337212795Sdim case TemplateArgument::Integral: 5338212795Sdim case TemplateArgument::Declaration: 5339243830Sdim case TemplateArgument::NullPtr: 5340212795Sdim case TemplateArgument::Pack: 5341243830Sdim // FIXME: Is this right? 5342212795Sdim return TemplateArgumentLocInfo(); 5343212795Sdim } 5344212795Sdim llvm_unreachable("unexpected template argument loc"); 5345212795Sdim} 5346212795Sdim 5347212795SdimTemplateArgumentLoc 5348234353SdimASTReader::ReadTemplateArgumentLoc(ModuleFile &F, 5349212795Sdim const RecordData &Record, unsigned &Index) { 5350218893Sdim TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 5351212795Sdim 5352212795Sdim if (Arg.getKind() == TemplateArgument::Expression) { 5353212795Sdim if (Record[Index++]) // bool InfoHasSameExpr. 5354212795Sdim return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 5355212795Sdim } 5356218893Sdim return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 5357212795Sdim Record, Index)); 5358212795Sdim} 5359212795Sdim 5360263508Sdimconst ASTTemplateArgumentListInfo* 5361263508SdimASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F, 5362263508Sdim const RecordData &Record, 5363263508Sdim unsigned &Index) { 5364263508Sdim SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index); 5365263508Sdim SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index); 5366263508Sdim unsigned NumArgsAsWritten = Record[Index++]; 5367263508Sdim TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc); 5368263508Sdim for (unsigned i = 0; i != NumArgsAsWritten; ++i) 5369263508Sdim TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index)); 5370263508Sdim return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo); 5371263508Sdim} 5372263508Sdim 5373212795SdimDecl *ASTReader::GetExternalDecl(uint32_t ID) { 5374212795Sdim return GetDecl(ID); 5375212795Sdim} 5376212795Sdim 5377234353Sdimuint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M, const RecordData &Record, 5378226633Sdim unsigned &Idx){ 5379226633Sdim if (Idx >= Record.size()) 5380218893Sdim return 0; 5381218893Sdim 5382226633Sdim unsigned LocalID = Record[Idx++]; 5383226633Sdim return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 5384218893Sdim} 5385218893Sdim 5386218893SdimCXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 5387226633Sdim RecordLocation Loc = getLocalBitOffset(Offset); 5388249423Sdim BitstreamCursor &Cursor = Loc.F->DeclsCursor; 5389218893Sdim SavedStreamPosition SavedPosition(Cursor); 5390226633Sdim Cursor.JumpToBit(Loc.Offset); 5391218893Sdim ReadingKindTracker ReadingKind(Read_Decl, *this); 5392218893Sdim RecordData Record; 5393218893Sdim unsigned Code = Cursor.ReadCode(); 5394249423Sdim unsigned RecCode = Cursor.readRecord(Code, Record); 5395218893Sdim if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 5396218893Sdim Error("Malformed AST file: missing C++ base specifiers"); 5397218893Sdim return 0; 5398218893Sdim } 5399218893Sdim 5400218893Sdim unsigned Idx = 0; 5401218893Sdim unsigned NumBases = Record[Idx++]; 5402226633Sdim void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 5403218893Sdim CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 5404218893Sdim for (unsigned I = 0; I != NumBases; ++I) 5405226633Sdim Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 5406218893Sdim return Bases; 5407218893Sdim} 5408218893Sdim 5409226633Sdimserialization::DeclID 5410243830SdimASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const { 5411226633Sdim if (LocalID < NUM_PREDEF_DECL_IDS) 5412226633Sdim return LocalID; 5413212795Sdim 5414226633Sdim ContinuousRangeMap<uint32_t, int, 2>::iterator I 5415226633Sdim = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 5416226633Sdim assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 5417226633Sdim 5418226633Sdim return LocalID + I->second; 5419212795Sdim} 5420212795Sdim 5421226633Sdimbool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 5422234353Sdim ModuleFile &M) const { 5423226633Sdim GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 5424226633Sdim assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5425226633Sdim return &M == I->second; 5426226633Sdim} 5427226633Sdim 5428249423SdimModuleFile *ASTReader::getOwningModuleFile(const Decl *D) { 5429234353Sdim if (!D->isFromASTFile()) 5430234353Sdim return 0; 5431234353Sdim GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID()); 5432234353Sdim assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5433234353Sdim return I->second; 5434234353Sdim} 5435234353Sdim 5436234353SdimSourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) { 5437234353Sdim if (ID < NUM_PREDEF_DECL_IDS) 5438234353Sdim return SourceLocation(); 5439234353Sdim 5440234353Sdim unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5441234353Sdim 5442234353Sdim if (Index > DeclsLoaded.size()) { 5443234353Sdim Error("declaration ID out-of-range for AST file"); 5444234353Sdim return SourceLocation(); 5445234353Sdim } 5446234353Sdim 5447234353Sdim if (Decl *D = DeclsLoaded[Index]) 5448234353Sdim return D->getLocation(); 5449234353Sdim 5450234353Sdim unsigned RawLocation = 0; 5451234353Sdim RecordLocation Rec = DeclCursorForID(ID, RawLocation); 5452234353Sdim return ReadSourceLocation(*Rec.F, RawLocation); 5453234353Sdim} 5454234353Sdim 5455212795SdimDecl *ASTReader::GetDecl(DeclID ID) { 5456226633Sdim if (ID < NUM_PREDEF_DECL_IDS) { 5457226633Sdim switch ((PredefinedDeclIDs)ID) { 5458226633Sdim case PREDEF_DECL_NULL_ID: 5459226633Sdim return 0; 5460226633Sdim 5461226633Sdim case PREDEF_DECL_TRANSLATION_UNIT_ID: 5462226633Sdim return Context.getTranslationUnitDecl(); 5463226633Sdim 5464226633Sdim case PREDEF_DECL_OBJC_ID_ID: 5465226633Sdim return Context.getObjCIdDecl(); 5466226633Sdim 5467226633Sdim case PREDEF_DECL_OBJC_SEL_ID: 5468226633Sdim return Context.getObjCSelDecl(); 5469226633Sdim 5470226633Sdim case PREDEF_DECL_OBJC_CLASS_ID: 5471226633Sdim return Context.getObjCClassDecl(); 5472226633Sdim 5473234353Sdim case PREDEF_DECL_OBJC_PROTOCOL_ID: 5474234353Sdim return Context.getObjCProtocolDecl(); 5475234353Sdim 5476226633Sdim case PREDEF_DECL_INT_128_ID: 5477226633Sdim return Context.getInt128Decl(); 5478226633Sdim 5479226633Sdim case PREDEF_DECL_UNSIGNED_INT_128_ID: 5480226633Sdim return Context.getUInt128Decl(); 5481226633Sdim 5482226633Sdim case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 5483226633Sdim return Context.getObjCInstanceTypeDecl(); 5484239462Sdim 5485239462Sdim case PREDEF_DECL_BUILTIN_VA_LIST_ID: 5486239462Sdim return Context.getBuiltinVaListDecl(); 5487226633Sdim } 5488226633Sdim } 5489226633Sdim 5490226633Sdim unsigned Index = ID - NUM_PREDEF_DECL_IDS; 5491212795Sdim 5492234353Sdim if (Index >= DeclsLoaded.size()) { 5493239462Sdim assert(0 && "declaration ID out-of-range for AST file"); 5494212795Sdim Error("declaration ID out-of-range for AST file"); 5495239462Sdim return 0; 5496212795Sdim } 5497226633Sdim 5498234353Sdim if (!DeclsLoaded[Index]) { 5499226633Sdim ReadDeclRecord(ID); 5500212795Sdim if (DeserializationListener) 5501212795Sdim DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 5502212795Sdim } 5503212795Sdim 5504212795Sdim return DeclsLoaded[Index]; 5505212795Sdim} 5506212795Sdim 5507234353SdimDeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M, 5508234353Sdim DeclID GlobalID) { 5509234353Sdim if (GlobalID < NUM_PREDEF_DECL_IDS) 5510234353Sdim return GlobalID; 5511234353Sdim 5512234353Sdim GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID); 5513234353Sdim assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 5514234353Sdim ModuleFile *Owner = I->second; 5515234353Sdim 5516234353Sdim llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos 5517234353Sdim = M.GlobalToLocalDeclIDs.find(Owner); 5518234353Sdim if (Pos == M.GlobalToLocalDeclIDs.end()) 5519234353Sdim return 0; 5520234353Sdim 5521234353Sdim return GlobalID - Owner->BaseDeclID + Pos->second; 5522234353Sdim} 5523234353Sdim 5524234353Sdimserialization::DeclID ASTReader::ReadDeclID(ModuleFile &F, 5525226633Sdim const RecordData &Record, 5526226633Sdim unsigned &Idx) { 5527226633Sdim if (Idx >= Record.size()) { 5528226633Sdim Error("Corrupted AST file"); 5529226633Sdim return 0; 5530226633Sdim } 5531226633Sdim 5532226633Sdim return getGlobalDeclID(F, Record[Idx++]); 5533226633Sdim} 5534226633Sdim 5535212795Sdim/// \brief Resolve the offset of a statement into a statement. 5536212795Sdim/// 5537212795Sdim/// This operation will read a new statement from the external 5538212795Sdim/// source each time it is called, and is meant to be used via a 5539212795Sdim/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 5540212795SdimStmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 5541218893Sdim // Switch case IDs are per Decl. 5542218893Sdim ClearSwitchCaseIDs(); 5543218893Sdim 5544212795Sdim // Offset here is a global offset across the entire chain. 5545226633Sdim RecordLocation Loc = getLocalBitOffset(Offset); 5546226633Sdim Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 5547226633Sdim return ReadStmtFromStream(*Loc.F); 5548212795Sdim} 5549212795Sdim 5550226633Sdimnamespace { 5551226633Sdim class FindExternalLexicalDeclsVisitor { 5552226633Sdim ASTReader &Reader; 5553226633Sdim const DeclContext *DC; 5554226633Sdim bool (*isKindWeWant)(Decl::Kind); 5555226633Sdim 5556226633Sdim SmallVectorImpl<Decl*> &Decls; 5557226633Sdim bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 5558212795Sdim 5559226633Sdim public: 5560226633Sdim FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 5561226633Sdim bool (*isKindWeWant)(Decl::Kind), 5562226633Sdim SmallVectorImpl<Decl*> &Decls) 5563226633Sdim : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 5564226633Sdim { 5565226633Sdim for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 5566226633Sdim PredefsVisited[I] = false; 5567226633Sdim } 5568218893Sdim 5569234353Sdim static bool visit(ModuleFile &M, bool Preorder, void *UserData) { 5570226633Sdim if (Preorder) 5571226633Sdim return false; 5572226633Sdim 5573226633Sdim FindExternalLexicalDeclsVisitor *This 5574226633Sdim = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 5575226633Sdim 5576234353Sdim ModuleFile::DeclContextInfosMap::iterator Info 5577226633Sdim = M.DeclContextInfos.find(This->DC); 5578226633Sdim if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 5579226633Sdim return false; 5580226633Sdim 5581226633Sdim // Load all of the declaration IDs 5582226633Sdim for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 5583226633Sdim *IDE = ID + Info->second.NumLexicalDecls; 5584226633Sdim ID != IDE; ++ID) { 5585226633Sdim if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 5586226633Sdim continue; 5587226633Sdim 5588226633Sdim // Don't add predefined declarations to the lexical context more 5589226633Sdim // than once. 5590226633Sdim if (ID->second < NUM_PREDEF_DECL_IDS) { 5591226633Sdim if (This->PredefsVisited[ID->second]) 5592226633Sdim continue; 5593226633Sdim 5594226633Sdim This->PredefsVisited[ID->second] = true; 5595226633Sdim } 5596226633Sdim 5597226633Sdim if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 5598226633Sdim if (!This->DC->isDeclInLexicalTraversal(D)) 5599226633Sdim This->Decls.push_back(D); 5600226633Sdim } 5601226633Sdim } 5602226633Sdim 5603226633Sdim return false; 5604218893Sdim } 5605226633Sdim }; 5606226633Sdim} 5607212795Sdim 5608226633SdimExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 5609226633Sdim bool (*isKindWeWant)(Decl::Kind), 5610226633Sdim SmallVectorImpl<Decl*> &Decls) { 5611226633Sdim // There might be lexical decls in multiple modules, for the TU at 5612226633Sdim // least. Walk all of the modules in the order they were loaded. 5613226633Sdim FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 5614226633Sdim ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 5615212795Sdim ++NumLexicalDeclContextsRead; 5616224145Sdim return ELR_Success; 5617212795Sdim} 5618212795Sdim 5619226633Sdimnamespace { 5620234353Sdim 5621234353Sdimclass DeclIDComp { 5622234353Sdim ASTReader &Reader; 5623234353Sdim ModuleFile &Mod; 5624234353Sdim 5625234353Sdimpublic: 5626234353Sdim DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {} 5627234353Sdim 5628234353Sdim bool operator()(LocalDeclID L, LocalDeclID R) const { 5629234353Sdim SourceLocation LHS = getLocation(L); 5630234353Sdim SourceLocation RHS = getLocation(R); 5631234353Sdim return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5632234353Sdim } 5633234353Sdim 5634234353Sdim bool operator()(SourceLocation LHS, LocalDeclID R) const { 5635234353Sdim SourceLocation RHS = getLocation(R); 5636234353Sdim return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5637234353Sdim } 5638234353Sdim 5639234353Sdim bool operator()(LocalDeclID L, SourceLocation RHS) const { 5640234353Sdim SourceLocation LHS = getLocation(L); 5641234353Sdim return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 5642234353Sdim } 5643234353Sdim 5644234353Sdim SourceLocation getLocation(LocalDeclID ID) const { 5645234353Sdim return Reader.getSourceManager().getFileLoc( 5646234353Sdim Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID))); 5647234353Sdim } 5648234353Sdim}; 5649234353Sdim 5650234353Sdim} 5651234353Sdim 5652234353Sdimvoid ASTReader::FindFileRegionDecls(FileID File, 5653234353Sdim unsigned Offset, unsigned Length, 5654234353Sdim SmallVectorImpl<Decl *> &Decls) { 5655234353Sdim SourceManager &SM = getSourceManager(); 5656234353Sdim 5657234353Sdim llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File); 5658234353Sdim if (I == FileDeclIDs.end()) 5659234353Sdim return; 5660234353Sdim 5661234353Sdim FileDeclsInfo &DInfo = I->second; 5662234353Sdim if (DInfo.Decls.empty()) 5663234353Sdim return; 5664234353Sdim 5665234353Sdim SourceLocation 5666234353Sdim BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset); 5667234353Sdim SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length); 5668234353Sdim 5669234353Sdim DeclIDComp DIDComp(*this, *DInfo.Mod); 5670234353Sdim ArrayRef<serialization::LocalDeclID>::iterator 5671234353Sdim BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5672234353Sdim BeginLoc, DIDComp); 5673234353Sdim if (BeginIt != DInfo.Decls.begin()) 5674234353Sdim --BeginIt; 5675234353Sdim 5676234353Sdim // If we are pointing at a top-level decl inside an objc container, we need 5677234353Sdim // to backtrack until we find it otherwise we will fail to report that the 5678234353Sdim // region overlaps with an objc container. 5679234353Sdim while (BeginIt != DInfo.Decls.begin() && 5680234353Sdim GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt)) 5681234353Sdim ->isTopLevelDeclInObjCContainer()) 5682234353Sdim --BeginIt; 5683234353Sdim 5684234353Sdim ArrayRef<serialization::LocalDeclID>::iterator 5685234353Sdim EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(), 5686234353Sdim EndLoc, DIDComp); 5687234353Sdim if (EndIt != DInfo.Decls.end()) 5688234353Sdim ++EndIt; 5689234353Sdim 5690234353Sdim for (ArrayRef<serialization::LocalDeclID>::iterator 5691234353Sdim DIt = BeginIt; DIt != EndIt; ++DIt) 5692234353Sdim Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt))); 5693234353Sdim} 5694234353Sdim 5695234353Sdimnamespace { 5696234353Sdim /// \brief ModuleFile visitor used to perform name lookup into a 5697226633Sdim /// declaration context. 5698226633Sdim class DeclContextNameLookupVisitor { 5699226633Sdim ASTReader &Reader; 5700249423Sdim SmallVectorImpl<const DeclContext *> &Contexts; 5701226633Sdim DeclarationName Name; 5702226633Sdim SmallVectorImpl<NamedDecl *> &Decls; 5703226633Sdim 5704226633Sdim public: 5705226633Sdim DeclContextNameLookupVisitor(ASTReader &Reader, 5706234353Sdim SmallVectorImpl<const DeclContext *> &Contexts, 5707234353Sdim DeclarationName Name, 5708226633Sdim SmallVectorImpl<NamedDecl *> &Decls) 5709234353Sdim : Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls) { } 5710226633Sdim 5711234353Sdim static bool visit(ModuleFile &M, void *UserData) { 5712226633Sdim DeclContextNameLookupVisitor *This 5713226633Sdim = static_cast<DeclContextNameLookupVisitor *>(UserData); 5714226633Sdim 5715226633Sdim // Check whether we have any visible declaration information for 5716226633Sdim // this context in this module. 5717234353Sdim ModuleFile::DeclContextInfosMap::iterator Info; 5718234353Sdim bool FoundInfo = false; 5719234353Sdim for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5720234353Sdim Info = M.DeclContextInfos.find(This->Contexts[I]); 5721234353Sdim if (Info != M.DeclContextInfos.end() && 5722234353Sdim Info->second.NameLookupTableData) { 5723234353Sdim FoundInfo = true; 5724234353Sdim break; 5725234353Sdim } 5726234353Sdim } 5727234353Sdim 5728234353Sdim if (!FoundInfo) 5729226633Sdim return false; 5730234353Sdim 5731226633Sdim // Look for this name within this module. 5732226633Sdim ASTDeclContextNameLookupTable *LookupTable = 5733234982Sdim Info->second.NameLookupTableData; 5734226633Sdim ASTDeclContextNameLookupTable::iterator Pos 5735226633Sdim = LookupTable->find(This->Name); 5736226633Sdim if (Pos == LookupTable->end()) 5737226633Sdim return false; 5738226633Sdim 5739226633Sdim bool FoundAnything = false; 5740226633Sdim ASTDeclContextNameLookupTrait::data_type Data = *Pos; 5741226633Sdim for (; Data.first != Data.second; ++Data.first) { 5742226633Sdim NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 5743226633Sdim if (!ND) 5744226633Sdim continue; 5745226633Sdim 5746226633Sdim if (ND->getDeclName() != This->Name) { 5747243830Sdim // A name might be null because the decl's redeclarable part is 5748243830Sdim // currently read before reading its name. The lookup is triggered by 5749243830Sdim // building that decl (likely indirectly), and so it is later in the 5750243830Sdim // sense of "already existing" and can be ignored here. 5751226633Sdim continue; 5752226633Sdim } 5753226633Sdim 5754226633Sdim // Record this declaration. 5755226633Sdim FoundAnything = true; 5756226633Sdim This->Decls.push_back(ND); 5757226633Sdim } 5758226633Sdim 5759226633Sdim return FoundAnything; 5760226633Sdim } 5761226633Sdim }; 5762226633Sdim} 5763226633Sdim 5764249423Sdim/// \brief Retrieve the "definitive" module file for the definition of the 5765249423Sdim/// given declaration context, if there is one. 5766249423Sdim/// 5767249423Sdim/// The "definitive" module file is the only place where we need to look to 5768249423Sdim/// find information about the declarations within the given declaration 5769249423Sdim/// context. For example, C++ and Objective-C classes, C structs/unions, and 5770249423Sdim/// Objective-C protocols, categories, and extensions are all defined in a 5771249423Sdim/// single place in the source code, so they have definitive module files 5772249423Sdim/// associated with them. C++ namespaces, on the other hand, can have 5773249423Sdim/// definitions in multiple different module files. 5774249423Sdim/// 5775249423Sdim/// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's 5776249423Sdim/// NDEBUG checking. 5777249423Sdimstatic ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC, 5778249423Sdim ASTReader &Reader) { 5779249423Sdim if (const DeclContext *DefDC = getDefinitiveDeclContext(DC)) 5780249423Sdim return Reader.getOwningModuleFile(cast<Decl>(DefDC)); 5781249423Sdim 5782249423Sdim return 0; 5783249423Sdim} 5784249423Sdim 5785249423Sdimbool 5786212795SdimASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 5787212795Sdim DeclarationName Name) { 5788212795Sdim assert(DC->hasExternalVisibleStorage() && 5789212795Sdim "DeclContext has no visible decls in storage"); 5790212795Sdim if (!Name) 5791249423Sdim return false; 5792212795Sdim 5793226633Sdim SmallVector<NamedDecl *, 64> Decls; 5794234353Sdim 5795234353Sdim // Compute the declaration contexts we need to look into. Multiple such 5796234353Sdim // declaration contexts occur when two declaration contexts from disjoint 5797234353Sdim // modules get merged, e.g., when two namespaces with the same name are 5798234353Sdim // independently defined in separate modules. 5799234353Sdim SmallVector<const DeclContext *, 2> Contexts; 5800234353Sdim Contexts.push_back(DC); 5801234353Sdim 5802234353Sdim if (DC->isNamespace()) { 5803234353Sdim MergedDeclsMap::iterator Merged 5804234353Sdim = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5805234353Sdim if (Merged != MergedDecls.end()) { 5806234353Sdim for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5807234353Sdim Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5808234353Sdim } 5809234353Sdim } 5810234353Sdim 5811234353Sdim DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls); 5812249423Sdim 5813249423Sdim // If we can definitively determine which module file to look into, 5814249423Sdim // only look there. Otherwise, look in all module files. 5815249423Sdim ModuleFile *Definitive; 5816249423Sdim if (Contexts.size() == 1 && 5817249423Sdim (Definitive = getDefinitiveModuleFileFor(DC, *this))) { 5818249423Sdim DeclContextNameLookupVisitor::visit(*Definitive, &Visitor); 5819249423Sdim } else { 5820249423Sdim ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 5821249423Sdim } 5822212795Sdim ++NumVisibleDeclContextsRead; 5823212795Sdim SetExternalVisibleDeclsForName(DC, Name, Decls); 5824249423Sdim return !Decls.empty(); 5825212795Sdim} 5826212795Sdim 5827234353Sdimnamespace { 5828234982Sdim /// \brief ModuleFile visitor used to retrieve all visible names in a 5829234353Sdim /// declaration context. 5830234982Sdim class DeclContextAllNamesVisitor { 5831234353Sdim ASTReader &Reader; 5832249423Sdim SmallVectorImpl<const DeclContext *> &Contexts; 5833263508Sdim DeclsMap &Decls; 5834249423Sdim bool VisitAll; 5835234353Sdim 5836234353Sdim public: 5837234982Sdim DeclContextAllNamesVisitor(ASTReader &Reader, 5838234982Sdim SmallVectorImpl<const DeclContext *> &Contexts, 5839263508Sdim DeclsMap &Decls, bool VisitAll) 5840249423Sdim : Reader(Reader), Contexts(Contexts), Decls(Decls), VisitAll(VisitAll) { } 5841234353Sdim 5842234353Sdim static bool visit(ModuleFile &M, void *UserData) { 5843234982Sdim DeclContextAllNamesVisitor *This 5844234982Sdim = static_cast<DeclContextAllNamesVisitor *>(UserData); 5845234353Sdim 5846234353Sdim // Check whether we have any visible declaration information for 5847234353Sdim // this context in this module. 5848234982Sdim ModuleFile::DeclContextInfosMap::iterator Info; 5849234982Sdim bool FoundInfo = false; 5850234982Sdim for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) { 5851234982Sdim Info = M.DeclContextInfos.find(This->Contexts[I]); 5852234982Sdim if (Info != M.DeclContextInfos.end() && 5853234982Sdim Info->second.NameLookupTableData) { 5854234982Sdim FoundInfo = true; 5855234982Sdim break; 5856234982Sdim } 5857234982Sdim } 5858234982Sdim 5859234982Sdim if (!FoundInfo) 5860234353Sdim return false; 5861234982Sdim 5862234353Sdim ASTDeclContextNameLookupTable *LookupTable = 5863234982Sdim Info->second.NameLookupTableData; 5864234982Sdim bool FoundAnything = false; 5865234982Sdim for (ASTDeclContextNameLookupTable::data_iterator 5866249423Sdim I = LookupTable->data_begin(), E = LookupTable->data_end(); 5867249423Sdim I != E; 5868249423Sdim ++I) { 5869234982Sdim ASTDeclContextNameLookupTrait::data_type Data = *I; 5870234982Sdim for (; Data.first != Data.second; ++Data.first) { 5871234982Sdim NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, 5872234982Sdim *Data.first); 5873234982Sdim if (!ND) 5874234982Sdim continue; 5875234982Sdim 5876234982Sdim // Record this declaration. 5877234982Sdim FoundAnything = true; 5878234982Sdim This->Decls[ND->getDeclName()].push_back(ND); 5879234982Sdim } 5880234353Sdim } 5881234353Sdim 5882249423Sdim return FoundAnything && !This->VisitAll; 5883234353Sdim } 5884234353Sdim }; 5885234353Sdim} 5886234353Sdim 5887234982Sdimvoid ASTReader::completeVisibleDeclsMap(const DeclContext *DC) { 5888234353Sdim if (!DC->hasExternalVisibleStorage()) 5889234353Sdim return; 5890263508Sdim DeclsMap Decls; 5891234982Sdim 5892234982Sdim // Compute the declaration contexts we need to look into. Multiple such 5893234982Sdim // declaration contexts occur when two declaration contexts from disjoint 5894234982Sdim // modules get merged, e.g., when two namespaces with the same name are 5895234982Sdim // independently defined in separate modules. 5896234982Sdim SmallVector<const DeclContext *, 2> Contexts; 5897234982Sdim Contexts.push_back(DC); 5898234982Sdim 5899234982Sdim if (DC->isNamespace()) { 5900234982Sdim MergedDeclsMap::iterator Merged 5901234982Sdim = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC))); 5902234982Sdim if (Merged != MergedDecls.end()) { 5903234982Sdim for (unsigned I = 0, N = Merged->second.size(); I != N; ++I) 5904234982Sdim Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I]))); 5905234982Sdim } 5906234982Sdim } 5907234982Sdim 5908249423Sdim DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls, 5909249423Sdim /*VisitAll=*/DC->isFileContext()); 5910234982Sdim ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor); 5911234982Sdim ++NumVisibleDeclContextsRead; 5912234982Sdim 5913263508Sdim for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) { 5914234982Sdim SetExternalVisibleDeclsForName(DC, I->first, I->second); 5915234982Sdim } 5916239462Sdim const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false); 5917234353Sdim} 5918234353Sdim 5919226633Sdim/// \brief Under non-PCH compilation the consumer receives the objc methods 5920226633Sdim/// before receiving the implementation, and codegen depends on this. 5921226633Sdim/// We simulate this by deserializing and passing to consumer the methods of the 5922226633Sdim/// implementation before passing the deserialized implementation decl. 5923226633Sdimstatic void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 5924226633Sdim ASTConsumer *Consumer) { 5925226633Sdim assert(ImplD && Consumer); 5926212795Sdim 5927226633Sdim for (ObjCImplDecl::method_iterator 5928226633Sdim I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 5929226633Sdim Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 5930212795Sdim 5931226633Sdim Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 5932212795Sdim} 5933212795Sdim 5934212795Sdimvoid ASTReader::PassInterestingDeclsToConsumer() { 5935212795Sdim assert(Consumer); 5936212795Sdim while (!InterestingDecls.empty()) { 5937226633Sdim Decl *D = InterestingDecls.front(); 5938212795Sdim InterestingDecls.pop_front(); 5939226633Sdim 5940234353Sdim PassInterestingDeclToConsumer(D); 5941212795Sdim } 5942212795Sdim} 5943212795Sdim 5944234353Sdimvoid ASTReader::PassInterestingDeclToConsumer(Decl *D) { 5945234353Sdim if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 5946234353Sdim PassObjCImplDeclToConsumer(ImplD, Consumer); 5947234353Sdim else 5948234353Sdim Consumer->HandleInterestingDecl(DeclGroupRef(D)); 5949234353Sdim} 5950234353Sdim 5951212795Sdimvoid ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 5952212795Sdim this->Consumer = Consumer; 5953212795Sdim 5954212795Sdim if (!Consumer) 5955212795Sdim return; 5956212795Sdim 5957212795Sdim for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 5958212795Sdim // Force deserialization of this decl, which will cause it to be queued for 5959212795Sdim // passing to the consumer. 5960212795Sdim GetDecl(ExternalDefinitions[I]); 5961212795Sdim } 5962226633Sdim ExternalDefinitions.clear(); 5963212795Sdim 5964212795Sdim PassInterestingDeclsToConsumer(); 5965212795Sdim} 5966212795Sdim 5967212795Sdimvoid ASTReader::PrintStats() { 5968212795Sdim std::fprintf(stderr, "*** AST File Statistics:\n"); 5969212795Sdim 5970212795Sdim unsigned NumTypesLoaded 5971212795Sdim = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 5972212795Sdim QualType()); 5973212795Sdim unsigned NumDeclsLoaded 5974212795Sdim = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 5975212795Sdim (Decl *)0); 5976212795Sdim unsigned NumIdentifiersLoaded 5977212795Sdim = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 5978212795Sdim IdentifiersLoaded.end(), 5979212795Sdim (IdentifierInfo *)0); 5980243830Sdim unsigned NumMacrosLoaded 5981243830Sdim = MacrosLoaded.size() - std::count(MacrosLoaded.begin(), 5982243830Sdim MacrosLoaded.end(), 5983243830Sdim (MacroInfo *)0); 5984212795Sdim unsigned NumSelectorsLoaded 5985212795Sdim = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 5986212795Sdim SelectorsLoaded.end(), 5987212795Sdim Selector()); 5988212795Sdim 5989226633Sdim if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 5990212795Sdim std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 5991212795Sdim NumSLocEntriesRead, TotalNumSLocEntries, 5992212795Sdim ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 5993212795Sdim if (!TypesLoaded.empty()) 5994212795Sdim std::fprintf(stderr, " %u/%u types read (%f%%)\n", 5995212795Sdim NumTypesLoaded, (unsigned)TypesLoaded.size(), 5996212795Sdim ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 5997212795Sdim if (!DeclsLoaded.empty()) 5998212795Sdim std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 5999212795Sdim NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 6000212795Sdim ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 6001212795Sdim if (!IdentifiersLoaded.empty()) 6002212795Sdim std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 6003212795Sdim NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 6004212795Sdim ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 6005243830Sdim if (!MacrosLoaded.empty()) 6006243830Sdim std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 6007243830Sdim NumMacrosLoaded, (unsigned)MacrosLoaded.size(), 6008243830Sdim ((float)NumMacrosLoaded/MacrosLoaded.size() * 100)); 6009212795Sdim if (!SelectorsLoaded.empty()) 6010212795Sdim std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 6011212795Sdim NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 6012212795Sdim ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 6013212795Sdim if (TotalNumStatements) 6014212795Sdim std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 6015212795Sdim NumStatementsRead, TotalNumStatements, 6016212795Sdim ((float)NumStatementsRead/TotalNumStatements * 100)); 6017212795Sdim if (TotalNumMacros) 6018212795Sdim std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 6019212795Sdim NumMacrosRead, TotalNumMacros, 6020212795Sdim ((float)NumMacrosRead/TotalNumMacros * 100)); 6021212795Sdim if (TotalLexicalDeclContexts) 6022212795Sdim std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 6023212795Sdim NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 6024212795Sdim ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 6025212795Sdim * 100)); 6026212795Sdim if (TotalVisibleDeclContexts) 6027212795Sdim std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 6028212795Sdim NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 6029212795Sdim ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 6030212795Sdim * 100)); 6031212795Sdim if (TotalNumMethodPoolEntries) { 6032212795Sdim std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 6033212795Sdim NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 6034212795Sdim ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 6035212795Sdim * 100)); 6036212795Sdim } 6037249423Sdim if (NumMethodPoolLookups) { 6038249423Sdim std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n", 6039249423Sdim NumMethodPoolHits, NumMethodPoolLookups, 6040249423Sdim ((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0)); 6041249423Sdim } 6042249423Sdim if (NumMethodPoolTableLookups) { 6043249423Sdim std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n", 6044249423Sdim NumMethodPoolTableHits, NumMethodPoolTableLookups, 6045249423Sdim ((float)NumMethodPoolTableHits/NumMethodPoolTableLookups 6046249423Sdim * 100.0)); 6047249423Sdim } 6048249423Sdim 6049249423Sdim if (NumIdentifierLookupHits) { 6050249423Sdim std::fprintf(stderr, 6051249423Sdim " %u / %u identifier table lookups succeeded (%f%%)\n", 6052249423Sdim NumIdentifierLookupHits, NumIdentifierLookups, 6053249423Sdim (double)NumIdentifierLookupHits*100.0/NumIdentifierLookups); 6054249423Sdim } 6055249423Sdim 6056249423Sdim if (GlobalIndex) { 6057249423Sdim std::fprintf(stderr, "\n"); 6058249423Sdim GlobalIndex->printStats(); 6059249423Sdim } 6060249423Sdim 6061212795Sdim std::fprintf(stderr, "\n"); 6062226633Sdim dump(); 6063226633Sdim std::fprintf(stderr, "\n"); 6064212795Sdim} 6065212795Sdim 6066234353Sdimtemplate<typename Key, typename ModuleFile, unsigned InitialCapacity> 6067226633Sdimstatic void 6068226633SdimdumpModuleIDMap(StringRef Name, 6069234353Sdim const ContinuousRangeMap<Key, ModuleFile *, 6070226633Sdim InitialCapacity> &Map) { 6071226633Sdim if (Map.begin() == Map.end()) 6072226633Sdim return; 6073226633Sdim 6074234353Sdim typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType; 6075226633Sdim llvm::errs() << Name << ":\n"; 6076226633Sdim for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 6077226633Sdim I != IEnd; ++I) { 6078226633Sdim llvm::errs() << " " << I->first << " -> " << I->second->FileName 6079226633Sdim << "\n"; 6080226633Sdim } 6081226633Sdim} 6082226633Sdim 6083226633Sdimvoid ASTReader::dump() { 6084234353Sdim llvm::errs() << "*** PCH/ModuleFile Remappings:\n"; 6085226633Sdim dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 6086226633Sdim dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 6087226633Sdim dumpModuleIDMap("Global type map", GlobalTypeMap); 6088226633Sdim dumpModuleIDMap("Global declaration map", GlobalDeclMap); 6089226633Sdim dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 6090243830Sdim dumpModuleIDMap("Global macro map", GlobalMacroMap); 6091234353Sdim dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap); 6092226633Sdim dumpModuleIDMap("Global selector map", GlobalSelectorMap); 6093226633Sdim dumpModuleIDMap("Global preprocessed entity map", 6094226633Sdim GlobalPreprocessedEntityMap); 6095226633Sdim 6096226633Sdim llvm::errs() << "\n*** PCH/Modules Loaded:"; 6097226633Sdim for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 6098226633Sdim MEnd = ModuleMgr.end(); 6099226633Sdim M != MEnd; ++M) 6100226633Sdim (*M)->dump(); 6101226633Sdim} 6102226633Sdim 6103221345Sdim/// Return the amount of memory used by memory buffers, breaking down 6104221345Sdim/// by heap-backed versus mmap'ed memory. 6105221345Sdimvoid ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 6106226633Sdim for (ModuleConstIterator I = ModuleMgr.begin(), 6107226633Sdim E = ModuleMgr.end(); I != E; ++I) { 6108226633Sdim if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 6109221345Sdim size_t bytes = buf->getBufferSize(); 6110221345Sdim switch (buf->getBufferKind()) { 6111221345Sdim case llvm::MemoryBuffer::MemoryBuffer_Malloc: 6112221345Sdim sizes.malloc_bytes += bytes; 6113221345Sdim break; 6114221345Sdim case llvm::MemoryBuffer::MemoryBuffer_MMap: 6115221345Sdim sizes.mmap_bytes += bytes; 6116221345Sdim break; 6117221345Sdim } 6118221345Sdim } 6119226633Sdim } 6120221345Sdim} 6121221345Sdim 6122212795Sdimvoid ASTReader::InitializeSema(Sema &S) { 6123212795Sdim SemaObj = &S; 6124243830Sdim S.addExternalSource(this); 6125212795Sdim 6126212795Sdim // Makes sure any declarations that were deserialized "too early" 6127212795Sdim // still get added to the identifier's declaration chains. 6128218893Sdim for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 6129251662Sdim pushExternalDeclIntoScope(PreloadedDecls[I], 6130251662Sdim PreloadedDecls[I]->getDeclName()); 6131212795Sdim } 6132212795Sdim PreloadedDecls.clear(); 6133212795Sdim 6134263508Sdim // FIXME: What happens if these are changed by a module import? 6135218893Sdim if (!FPPragmaOptions.empty()) { 6136218893Sdim assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 6137218893Sdim SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 6138218893Sdim } 6139218893Sdim 6140263508Sdim // FIXME: What happens if these are changed by a module import? 6141218893Sdim if (!OpenCLExtensions.empty()) { 6142218893Sdim unsigned I = 0; 6143218893Sdim#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 6144218893Sdim#include "clang/Basic/OpenCLExtensions.def" 6145218893Sdim 6146218893Sdim assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 6147218893Sdim } 6148263508Sdim 6149263508Sdim UpdateSema(); 6150212795Sdim} 6151212795Sdim 6152263508Sdimvoid ASTReader::UpdateSema() { 6153263508Sdim assert(SemaObj && "no Sema to update"); 6154263508Sdim 6155263508Sdim // Load the offsets of the declarations that Sema references. 6156263508Sdim // They will be lazily deserialized when needed. 6157263508Sdim if (!SemaDeclRefs.empty()) { 6158263508Sdim assert(SemaDeclRefs.size() % 2 == 0); 6159263508Sdim for (unsigned I = 0; I != SemaDeclRefs.size(); I += 2) { 6160263508Sdim if (!SemaObj->StdNamespace) 6161263508Sdim SemaObj->StdNamespace = SemaDeclRefs[I]; 6162263508Sdim if (!SemaObj->StdBadAlloc) 6163263508Sdim SemaObj->StdBadAlloc = SemaDeclRefs[I+1]; 6164263508Sdim } 6165263508Sdim SemaDeclRefs.clear(); 6166263508Sdim } 6167263508Sdim} 6168263508Sdim 6169212795SdimIdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 6170243830Sdim // Note that we are loading an identifier. 6171243830Sdim Deserializing AnIdentifier(this); 6172249423Sdim StringRef Name(NameStart, NameEnd - NameStart); 6173249423Sdim 6174249423Sdim // If there is a global index, look there first to determine which modules 6175249423Sdim // provably do not have any results for this identifier. 6176249423Sdim GlobalModuleIndex::HitSet Hits; 6177249423Sdim GlobalModuleIndex::HitSet *HitsPtr = 0; 6178249423Sdim if (!loadGlobalIndex()) { 6179249423Sdim if (GlobalIndex->lookupIdentifier(Name, Hits)) { 6180249423Sdim HitsPtr = &Hits; 6181249423Sdim } 6182249423Sdim } 6183249423Sdim IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0, 6184249423Sdim NumIdentifierLookups, 6185249423Sdim NumIdentifierLookupHits); 6186249423Sdim ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor, HitsPtr); 6187234353Sdim IdentifierInfo *II = Visitor.getIdentifierInfo(); 6188234353Sdim markIdentifierUpToDate(II); 6189234353Sdim return II; 6190212795Sdim} 6191212795Sdim 6192218893Sdimnamespace clang { 6193218893Sdim /// \brief An identifier-lookup iterator that enumerates all of the 6194218893Sdim /// identifiers stored within a set of AST files. 6195218893Sdim class ASTIdentifierIterator : public IdentifierIterator { 6196218893Sdim /// \brief The AST reader whose identifiers are being enumerated. 6197218893Sdim const ASTReader &Reader; 6198218893Sdim 6199218893Sdim /// \brief The current index into the chain of AST files stored in 6200218893Sdim /// the AST reader. 6201218893Sdim unsigned Index; 6202218893Sdim 6203218893Sdim /// \brief The current position within the identifier lookup table 6204218893Sdim /// of the current AST file. 6205218893Sdim ASTIdentifierLookupTable::key_iterator Current; 6206218893Sdim 6207218893Sdim /// \brief The end position within the identifier lookup table of 6208218893Sdim /// the current AST file. 6209218893Sdim ASTIdentifierLookupTable::key_iterator End; 6210218893Sdim 6211218893Sdim public: 6212218893Sdim explicit ASTIdentifierIterator(const ASTReader &Reader); 6213218893Sdim 6214226633Sdim virtual StringRef Next(); 6215218893Sdim }; 6216218893Sdim} 6217218893Sdim 6218218893SdimASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 6219226633Sdim : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 6220218893Sdim ASTIdentifierLookupTable *IdTable 6221226633Sdim = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 6222218893Sdim Current = IdTable->key_begin(); 6223218893Sdim End = IdTable->key_end(); 6224218893Sdim} 6225218893Sdim 6226226633SdimStringRef ASTIdentifierIterator::Next() { 6227218893Sdim while (Current == End) { 6228218893Sdim // If we have exhausted all of our AST files, we're done. 6229218893Sdim if (Index == 0) 6230226633Sdim return StringRef(); 6231218893Sdim 6232218893Sdim --Index; 6233218893Sdim ASTIdentifierLookupTable *IdTable 6234226633Sdim = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 6235226633Sdim IdentifierLookupTable; 6236218893Sdim Current = IdTable->key_begin(); 6237218893Sdim End = IdTable->key_end(); 6238218893Sdim } 6239218893Sdim 6240218893Sdim // We have any identifiers remaining in the current AST file; return 6241218893Sdim // the next one. 6242249423Sdim StringRef Result = *Current; 6243218893Sdim ++Current; 6244249423Sdim return Result; 6245218893Sdim} 6246218893Sdim 6247251662SdimIdentifierIterator *ASTReader::getIdentifiers() { 6248251662Sdim if (!loadGlobalIndex()) 6249251662Sdim return GlobalIndex->createIdentifierIterator(); 6250251662Sdim 6251218893Sdim return new ASTIdentifierIterator(*this); 6252218893Sdim} 6253218893Sdim 6254226633Sdimnamespace clang { namespace serialization { 6255226633Sdim class ReadMethodPoolVisitor { 6256226633Sdim ASTReader &Reader; 6257234353Sdim Selector Sel; 6258234353Sdim unsigned PriorGeneration; 6259251662Sdim unsigned InstanceBits; 6260251662Sdim unsigned FactoryBits; 6261249423Sdim SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 6262249423Sdim SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 6263212795Sdim 6264226633Sdim public: 6265234353Sdim ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel, 6266234353Sdim unsigned PriorGeneration) 6267251662Sdim : Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration), 6268251662Sdim InstanceBits(0), FactoryBits(0) { } 6269226633Sdim 6270234353Sdim static bool visit(ModuleFile &M, void *UserData) { 6271226633Sdim ReadMethodPoolVisitor *This 6272226633Sdim = static_cast<ReadMethodPoolVisitor *>(UserData); 6273226633Sdim 6274226633Sdim if (!M.SelectorLookupTable) 6275226633Sdim return false; 6276226633Sdim 6277234353Sdim // If we've already searched this module file, skip it now. 6278234353Sdim if (M.Generation <= This->PriorGeneration) 6279234353Sdim return true; 6280234353Sdim 6281249423Sdim ++This->Reader.NumMethodPoolTableLookups; 6282226633Sdim ASTSelectorLookupTable *PoolTable 6283226633Sdim = (ASTSelectorLookupTable*)M.SelectorLookupTable; 6284226633Sdim ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 6285226633Sdim if (Pos == PoolTable->end()) 6286226633Sdim return false; 6287249423Sdim 6288249423Sdim ++This->Reader.NumMethodPoolTableHits; 6289226633Sdim ++This->Reader.NumSelectorsRead; 6290212795Sdim // FIXME: Not quite happy with the statistics here. We probably should 6291212795Sdim // disable this tracking when called via LoadSelector. 6292212795Sdim // Also, should entries without methods count as misses? 6293226633Sdim ++This->Reader.NumMethodPoolEntriesRead; 6294212795Sdim ASTSelectorLookupTrait::data_type Data = *Pos; 6295226633Sdim if (This->Reader.DeserializationListener) 6296226633Sdim This->Reader.DeserializationListener->SelectorRead(Data.ID, 6297226633Sdim This->Sel); 6298226633Sdim 6299226633Sdim This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 6300226633Sdim This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 6301251662Sdim This->InstanceBits = Data.InstanceBits; 6302251662Sdim This->FactoryBits = Data.FactoryBits; 6303226633Sdim return true; 6304212795Sdim } 6305226633Sdim 6306226633Sdim /// \brief Retrieve the instance methods found by this visitor. 6307234353Sdim ArrayRef<ObjCMethodDecl *> getInstanceMethods() const { 6308234353Sdim return InstanceMethods; 6309226633Sdim } 6310212795Sdim 6311226633Sdim /// \brief Retrieve the instance methods found by this visitor. 6312234353Sdim ArrayRef<ObjCMethodDecl *> getFactoryMethods() const { 6313234353Sdim return FactoryMethods; 6314226633Sdim } 6315251662Sdim 6316251662Sdim unsigned getInstanceBits() const { return InstanceBits; } 6317251662Sdim unsigned getFactoryBits() const { return FactoryBits; } 6318226633Sdim }; 6319226633Sdim} } // end namespace clang::serialization 6320226633Sdim 6321234353Sdim/// \brief Add the given set of methods to the method list. 6322234353Sdimstatic void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods, 6323234353Sdim ObjCMethodList &List) { 6324234353Sdim for (unsigned I = 0, N = Methods.size(); I != N; ++I) { 6325234353Sdim S.addMethodToGlobalList(&List, Methods[I]); 6326234353Sdim } 6327234353Sdim} 6328234353Sdim 6329234353Sdimvoid ASTReader::ReadMethodPool(Selector Sel) { 6330234353Sdim // Get the selector generation and update it to the current generation. 6331234353Sdim unsigned &Generation = SelectorGeneration[Sel]; 6332234353Sdim unsigned PriorGeneration = Generation; 6333234353Sdim Generation = CurrentGeneration; 6334234353Sdim 6335234353Sdim // Search for methods defined with this selector. 6336249423Sdim ++NumMethodPoolLookups; 6337234353Sdim ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration); 6338226633Sdim ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 6339226633Sdim 6340234353Sdim if (Visitor.getInstanceMethods().empty() && 6341249423Sdim Visitor.getFactoryMethods().empty()) 6342234353Sdim return; 6343249423Sdim 6344249423Sdim ++NumMethodPoolHits; 6345249423Sdim 6346234353Sdim if (!getSema()) 6347234353Sdim return; 6348234353Sdim 6349234353Sdim Sema &S = *getSema(); 6350234353Sdim Sema::GlobalMethodPool::iterator Pos 6351234353Sdim = S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first; 6352234353Sdim 6353234353Sdim addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first); 6354234353Sdim addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second); 6355251662Sdim Pos->second.first.setBits(Visitor.getInstanceBits()); 6356251662Sdim Pos->second.second.setBits(Visitor.getFactoryBits()); 6357212795Sdim} 6358212795Sdim 6359224145Sdimvoid ASTReader::ReadKnownNamespaces( 6360226633Sdim SmallVectorImpl<NamespaceDecl *> &Namespaces) { 6361224145Sdim Namespaces.clear(); 6362224145Sdim 6363224145Sdim for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 6364224145Sdim if (NamespaceDecl *Namespace 6365224145Sdim = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 6366224145Sdim Namespaces.push_back(Namespace); 6367224145Sdim } 6368224145Sdim} 6369224145Sdim 6370249423Sdimvoid ASTReader::ReadUndefinedButUsed( 6371249423Sdim llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) { 6372249423Sdim for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) { 6373249423Sdim NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++])); 6374249423Sdim SourceLocation Loc = 6375249423Sdim SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]); 6376249423Sdim Undefined.insert(std::make_pair(D, Loc)); 6377249423Sdim } 6378249423Sdim} 6379249423Sdim 6380226633Sdimvoid ASTReader::ReadTentativeDefinitions( 6381226633Sdim SmallVectorImpl<VarDecl *> &TentativeDefs) { 6382226633Sdim for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 6383226633Sdim VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 6384226633Sdim if (Var) 6385226633Sdim TentativeDefs.push_back(Var); 6386226633Sdim } 6387226633Sdim TentativeDefinitions.clear(); 6388226633Sdim} 6389226633Sdim 6390226633Sdimvoid ASTReader::ReadUnusedFileScopedDecls( 6391226633Sdim SmallVectorImpl<const DeclaratorDecl *> &Decls) { 6392226633Sdim for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 6393226633Sdim DeclaratorDecl *D 6394226633Sdim = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 6395226633Sdim if (D) 6396226633Sdim Decls.push_back(D); 6397226633Sdim } 6398226633Sdim UnusedFileScopedDecls.clear(); 6399226633Sdim} 6400226633Sdim 6401226633Sdimvoid ASTReader::ReadDelegatingConstructors( 6402226633Sdim SmallVectorImpl<CXXConstructorDecl *> &Decls) { 6403226633Sdim for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 6404226633Sdim CXXConstructorDecl *D 6405226633Sdim = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 6406226633Sdim if (D) 6407226633Sdim Decls.push_back(D); 6408226633Sdim } 6409226633Sdim DelegatingCtorDecls.clear(); 6410226633Sdim} 6411226633Sdim 6412226633Sdimvoid ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 6413226633Sdim for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 6414226633Sdim TypedefNameDecl *D 6415226633Sdim = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 6416226633Sdim if (D) 6417226633Sdim Decls.push_back(D); 6418226633Sdim } 6419226633Sdim ExtVectorDecls.clear(); 6420226633Sdim} 6421226633Sdim 6422226633Sdimvoid ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 6423226633Sdim for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 6424226633Sdim CXXRecordDecl *D 6425226633Sdim = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 6426226633Sdim if (D) 6427226633Sdim Decls.push_back(D); 6428226633Sdim } 6429226633Sdim DynamicClasses.clear(); 6430226633Sdim} 6431226633Sdim 6432226633Sdimvoid 6433249423SdimASTReader::ReadLocallyScopedExternCDecls(SmallVectorImpl<NamedDecl *> &Decls) { 6434249423Sdim for (unsigned I = 0, N = LocallyScopedExternCDecls.size(); I != N; ++I) { 6435249423Sdim NamedDecl *D 6436249423Sdim = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternCDecls[I])); 6437226633Sdim if (D) 6438226633Sdim Decls.push_back(D); 6439226633Sdim } 6440249423Sdim LocallyScopedExternCDecls.clear(); 6441226633Sdim} 6442226633Sdim 6443226633Sdimvoid ASTReader::ReadReferencedSelectors( 6444226633Sdim SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 6445226633Sdim if (ReferencedSelectorsData.empty()) 6446226633Sdim return; 6447226633Sdim 6448226633Sdim // If there are @selector references added them to its pool. This is for 6449226633Sdim // implementation of -Wselector. 6450226633Sdim unsigned int DataSize = ReferencedSelectorsData.size()-1; 6451226633Sdim unsigned I = 0; 6452226633Sdim while (I < DataSize) { 6453226633Sdim Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 6454226633Sdim SourceLocation SelLoc 6455226633Sdim = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 6456226633Sdim Sels.push_back(std::make_pair(Sel, SelLoc)); 6457226633Sdim } 6458226633Sdim ReferencedSelectorsData.clear(); 6459226633Sdim} 6460226633Sdim 6461226633Sdimvoid ASTReader::ReadWeakUndeclaredIdentifiers( 6462226633Sdim SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 6463226633Sdim if (WeakUndeclaredIdentifiers.empty()) 6464226633Sdim return; 6465226633Sdim 6466226633Sdim for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 6467226633Sdim IdentifierInfo *WeakId 6468226633Sdim = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6469226633Sdim IdentifierInfo *AliasId 6470226633Sdim = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 6471226633Sdim SourceLocation Loc 6472226633Sdim = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 6473226633Sdim bool Used = WeakUndeclaredIdentifiers[I++]; 6474226633Sdim WeakInfo WI(AliasId, Loc); 6475226633Sdim WI.setUsed(Used); 6476226633Sdim WeakIDs.push_back(std::make_pair(WeakId, WI)); 6477226633Sdim } 6478226633Sdim WeakUndeclaredIdentifiers.clear(); 6479226633Sdim} 6480226633Sdim 6481226633Sdimvoid ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 6482226633Sdim for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 6483226633Sdim ExternalVTableUse VT; 6484226633Sdim VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 6485226633Sdim VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 6486226633Sdim VT.DefinitionRequired = VTableUses[Idx++]; 6487226633Sdim VTables.push_back(VT); 6488226633Sdim } 6489226633Sdim 6490226633Sdim VTableUses.clear(); 6491226633Sdim} 6492226633Sdim 6493226633Sdimvoid ASTReader::ReadPendingInstantiations( 6494226633Sdim SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 6495226633Sdim for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 6496226633Sdim ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 6497226633Sdim SourceLocation Loc 6498226633Sdim = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 6499243830Sdim 6500226633Sdim Pending.push_back(std::make_pair(D, Loc)); 6501226633Sdim } 6502226633Sdim PendingInstantiations.clear(); 6503226633Sdim} 6504226633Sdim 6505263508Sdimvoid ASTReader::ReadLateParsedTemplates( 6506263508Sdim llvm::DenseMap<const FunctionDecl *, LateParsedTemplate *> &LPTMap) { 6507263508Sdim for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N; 6508263508Sdim /* In loop */) { 6509263508Sdim FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++])); 6510263508Sdim 6511263508Sdim LateParsedTemplate *LT = new LateParsedTemplate; 6512263508Sdim LT->D = GetDecl(LateParsedTemplates[Idx++]); 6513263508Sdim 6514263508Sdim ModuleFile *F = getOwningModuleFile(LT->D); 6515263508Sdim assert(F && "No module"); 6516263508Sdim 6517263508Sdim unsigned TokN = LateParsedTemplates[Idx++]; 6518263508Sdim LT->Toks.reserve(TokN); 6519263508Sdim for (unsigned T = 0; T < TokN; ++T) 6520263508Sdim LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx)); 6521263508Sdim 6522263508Sdim LPTMap[FD] = LT; 6523263508Sdim } 6524263508Sdim 6525263508Sdim LateParsedTemplates.clear(); 6526263508Sdim} 6527263508Sdim 6528212795Sdimvoid ASTReader::LoadSelector(Selector Sel) { 6529212795Sdim // It would be complicated to avoid reading the methods anyway. So don't. 6530212795Sdim ReadMethodPool(Sel); 6531212795Sdim} 6532212795Sdim 6533226633Sdimvoid ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 6534212795Sdim assert(ID && "Non-zero identifier ID required"); 6535212795Sdim assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 6536212795Sdim IdentifiersLoaded[ID - 1] = II; 6537212795Sdim if (DeserializationListener) 6538212795Sdim DeserializationListener->IdentifierRead(ID, II); 6539212795Sdim} 6540212795Sdim 6541212795Sdim/// \brief Set the globally-visible declarations associated with the given 6542212795Sdim/// identifier. 6543212795Sdim/// 6544212795Sdim/// If the AST reader is currently in a state where the given declaration IDs 6545212795Sdim/// cannot safely be resolved, they are queued until it is safe to resolve 6546212795Sdim/// them. 6547212795Sdim/// 6548212795Sdim/// \param II an IdentifierInfo that refers to one or more globally-visible 6549212795Sdim/// declarations. 6550212795Sdim/// 6551212795Sdim/// \param DeclIDs the set of declaration IDs with the name @p II that are 6552212795Sdim/// visible at global scope. 6553212795Sdim/// 6554249423Sdim/// \param Decls if non-null, this vector will be populated with the set of 6555249423Sdim/// deserialized declarations. These declarations will not be pushed into 6556249423Sdim/// scope. 6557212795Sdimvoid 6558212795SdimASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 6559226633Sdim const SmallVectorImpl<uint32_t> &DeclIDs, 6560249423Sdim SmallVectorImpl<Decl *> *Decls) { 6561249423Sdim if (NumCurrentElementsDeserializing && !Decls) { 6562249423Sdim PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end()); 6563212795Sdim return; 6564212795Sdim } 6565212795Sdim 6566212795Sdim for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 6567212795Sdim NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 6568212795Sdim if (SemaObj) { 6569249423Sdim // If we're simply supposed to record the declarations, do so now. 6570249423Sdim if (Decls) { 6571249423Sdim Decls->push_back(D); 6572249423Sdim continue; 6573249423Sdim } 6574249423Sdim 6575234353Sdim // Introduce this declaration into the translation-unit scope 6576234353Sdim // and add it to the declaration chain for this identifier, so 6577234353Sdim // that (unqualified) name lookup will find it. 6578251662Sdim pushExternalDeclIntoScope(D, II); 6579212795Sdim } else { 6580212795Sdim // Queue this declaration so that it will be added to the 6581212795Sdim // translation unit scope and identifier's declaration chain 6582212795Sdim // once a Sema object is known. 6583212795Sdim PreloadedDecls.push_back(D); 6584212795Sdim } 6585212795Sdim } 6586212795Sdim} 6587212795Sdim 6588226633SdimIdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 6589212795Sdim if (ID == 0) 6590212795Sdim return 0; 6591212795Sdim 6592212795Sdim if (IdentifiersLoaded.empty()) { 6593212795Sdim Error("no identifier table in AST file"); 6594212795Sdim return 0; 6595212795Sdim } 6596212795Sdim 6597212795Sdim ID -= 1; 6598212795Sdim if (!IdentifiersLoaded[ID]) { 6599226633Sdim GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 6600226633Sdim assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 6601234353Sdim ModuleFile *M = I->second; 6602226633Sdim unsigned Index = ID - M->BaseIdentifierID; 6603226633Sdim const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 6604212795Sdim 6605212795Sdim // All of the strings in the AST file are preceded by a 16-bit length. 6606212795Sdim // Extract that 16-bit length to avoid having to execute strlen(). 6607212795Sdim // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 6608212795Sdim // unsigned integers. This is important to avoid integer overflow when 6609212795Sdim // we cast them to 'unsigned'. 6610212795Sdim const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 6611212795Sdim unsigned StrLen = (((unsigned) StrLenPtr[0]) 6612212795Sdim | (((unsigned) StrLenPtr[1]) << 8)) - 1; 6613212795Sdim IdentifiersLoaded[ID] 6614226633Sdim = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 6615212795Sdim if (DeserializationListener) 6616212795Sdim DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 6617212795Sdim } 6618212795Sdim 6619212795Sdim return IdentifiersLoaded[ID]; 6620212795Sdim} 6621212795Sdim 6622234353SdimIdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) { 6623226633Sdim return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 6624226633Sdim} 6625226633Sdim 6626234353SdimIdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) { 6627226633Sdim if (LocalID < NUM_PREDEF_IDENT_IDS) 6628226633Sdim return LocalID; 6629226633Sdim 6630226633Sdim ContinuousRangeMap<uint32_t, int, 2>::iterator I 6631226633Sdim = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 6632226633Sdim assert(I != M.IdentifierRemap.end() 6633226633Sdim && "Invalid index into identifier index remap"); 6634226633Sdim 6635226633Sdim return LocalID + I->second; 6636226633Sdim} 6637226633Sdim 6638249423SdimMacroInfo *ASTReader::getMacro(MacroID ID) { 6639243830Sdim if (ID == 0) 6640243830Sdim return 0; 6641243830Sdim 6642243830Sdim if (MacrosLoaded.empty()) { 6643243830Sdim Error("no macro table in AST file"); 6644243830Sdim return 0; 6645243830Sdim } 6646243830Sdim 6647243830Sdim ID -= NUM_PREDEF_MACRO_IDS; 6648243830Sdim if (!MacrosLoaded[ID]) { 6649243830Sdim GlobalMacroMapType::iterator I 6650243830Sdim = GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS); 6651243830Sdim assert(I != GlobalMacroMap.end() && "Corrupted global macro map"); 6652243830Sdim ModuleFile *M = I->second; 6653243830Sdim unsigned Index = ID - M->BaseMacroID; 6654249423Sdim MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]); 6655249423Sdim 6656249423Sdim if (DeserializationListener) 6657249423Sdim DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS, 6658249423Sdim MacrosLoaded[ID]); 6659243830Sdim } 6660243830Sdim 6661243830Sdim return MacrosLoaded[ID]; 6662212795Sdim} 6663212795Sdim 6664243830SdimMacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) { 6665243830Sdim if (LocalID < NUM_PREDEF_MACRO_IDS) 6666243830Sdim return LocalID; 6667243830Sdim 6668243830Sdim ContinuousRangeMap<uint32_t, int, 2>::iterator I 6669243830Sdim = M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS); 6670243830Sdim assert(I != M.MacroRemap.end() && "Invalid index into macro index remap"); 6671243830Sdim 6672243830Sdim return LocalID + I->second; 6673243830Sdim} 6674243830Sdim 6675234353Sdimserialization::SubmoduleID 6676234353SdimASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) { 6677234353Sdim if (LocalID < NUM_PREDEF_SUBMODULE_IDS) 6678234353Sdim return LocalID; 6679234353Sdim 6680234353Sdim ContinuousRangeMap<uint32_t, int, 2>::iterator I 6681234353Sdim = M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS); 6682234353Sdim assert(I != M.SubmoduleRemap.end() 6683243830Sdim && "Invalid index into submodule index remap"); 6684234353Sdim 6685234353Sdim return LocalID + I->second; 6686234353Sdim} 6687234353Sdim 6688234353SdimModule *ASTReader::getSubmodule(SubmoduleID GlobalID) { 6689234353Sdim if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) { 6690234353Sdim assert(GlobalID == 0 && "Unhandled global submodule ID"); 6691234353Sdim return 0; 6692234353Sdim } 6693234353Sdim 6694234353Sdim if (GlobalID > SubmodulesLoaded.size()) { 6695234353Sdim Error("submodule ID out of range in AST file"); 6696234353Sdim return 0; 6697234353Sdim } 6698234353Sdim 6699234353Sdim return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS]; 6700234353Sdim} 6701249423Sdim 6702249423SdimModule *ASTReader::getModule(unsigned ID) { 6703249423Sdim return getSubmodule(ID); 6704249423Sdim} 6705249423Sdim 6706234353SdimSelector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) { 6707226633Sdim return DecodeSelector(getGlobalSelectorID(M, LocalID)); 6708226633Sdim} 6709226633Sdim 6710226633SdimSelector ASTReader::DecodeSelector(serialization::SelectorID ID) { 6711212795Sdim if (ID == 0) 6712212795Sdim return Selector(); 6713212795Sdim 6714212795Sdim if (ID > SelectorsLoaded.size()) { 6715212795Sdim Error("selector ID out of range in AST file"); 6716212795Sdim return Selector(); 6717212795Sdim } 6718212795Sdim 6719212795Sdim if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 6720212795Sdim // Load this selector from the selector table. 6721226633Sdim GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 6722226633Sdim assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 6723234353Sdim ModuleFile &M = *I->second; 6724226633Sdim ASTSelectorLookupTrait Trait(*this, M); 6725226633Sdim unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 6726226633Sdim SelectorsLoaded[ID - 1] = 6727226633Sdim Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 6728226633Sdim if (DeserializationListener) 6729226633Sdim DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 6730212795Sdim } 6731212795Sdim 6732212795Sdim return SelectorsLoaded[ID - 1]; 6733212795Sdim} 6734212795Sdim 6735226633SdimSelector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 6736212795Sdim return DecodeSelector(ID); 6737212795Sdim} 6738212795Sdim 6739212795Sdimuint32_t ASTReader::GetNumExternalSelectors() { 6740212795Sdim // ID 0 (the null selector) is considered an external selector. 6741212795Sdim return getTotalNumSelectors() + 1; 6742212795Sdim} 6743212795Sdim 6744226633Sdimserialization::SelectorID 6745234353SdimASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const { 6746226633Sdim if (LocalID < NUM_PREDEF_SELECTOR_IDS) 6747226633Sdim return LocalID; 6748226633Sdim 6749226633Sdim ContinuousRangeMap<uint32_t, int, 2>::iterator I 6750226633Sdim = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 6751226633Sdim assert(I != M.SelectorRemap.end() 6752243830Sdim && "Invalid index into selector index remap"); 6753226633Sdim 6754226633Sdim return LocalID + I->second; 6755226633Sdim} 6756226633Sdim 6757212795SdimDeclarationName 6758234353SdimASTReader::ReadDeclarationName(ModuleFile &F, 6759226633Sdim const RecordData &Record, unsigned &Idx) { 6760212795Sdim DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 6761212795Sdim switch (Kind) { 6762212795Sdim case DeclarationName::Identifier: 6763226633Sdim return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 6764212795Sdim 6765212795Sdim case DeclarationName::ObjCZeroArgSelector: 6766212795Sdim case DeclarationName::ObjCOneArgSelector: 6767212795Sdim case DeclarationName::ObjCMultiArgSelector: 6768226633Sdim return DeclarationName(ReadSelector(F, Record, Idx)); 6769212795Sdim 6770212795Sdim case DeclarationName::CXXConstructorName: 6771226633Sdim return Context.DeclarationNames.getCXXConstructorName( 6772226633Sdim Context.getCanonicalType(readType(F, Record, Idx))); 6773212795Sdim 6774212795Sdim case DeclarationName::CXXDestructorName: 6775226633Sdim return Context.DeclarationNames.getCXXDestructorName( 6776226633Sdim Context.getCanonicalType(readType(F, Record, Idx))); 6777212795Sdim 6778212795Sdim case DeclarationName::CXXConversionFunctionName: 6779226633Sdim return Context.DeclarationNames.getCXXConversionFunctionName( 6780226633Sdim Context.getCanonicalType(readType(F, Record, Idx))); 6781212795Sdim 6782212795Sdim case DeclarationName::CXXOperatorName: 6783226633Sdim return Context.DeclarationNames.getCXXOperatorName( 6784212795Sdim (OverloadedOperatorKind)Record[Idx++]); 6785212795Sdim 6786212795Sdim case DeclarationName::CXXLiteralOperatorName: 6787226633Sdim return Context.DeclarationNames.getCXXLiteralOperatorName( 6788226633Sdim GetIdentifierInfo(F, Record, Idx)); 6789212795Sdim 6790212795Sdim case DeclarationName::CXXUsingDirective: 6791212795Sdim return DeclarationName::getUsingDirectiveName(); 6792212795Sdim } 6793212795Sdim 6794234353Sdim llvm_unreachable("Invalid NameKind!"); 6795212795Sdim} 6796212795Sdim 6797234353Sdimvoid ASTReader::ReadDeclarationNameLoc(ModuleFile &F, 6798218893Sdim DeclarationNameLoc &DNLoc, 6799218893Sdim DeclarationName Name, 6800218893Sdim const RecordData &Record, unsigned &Idx) { 6801218893Sdim switch (Name.getNameKind()) { 6802218893Sdim case DeclarationName::CXXConstructorName: 6803218893Sdim case DeclarationName::CXXDestructorName: 6804218893Sdim case DeclarationName::CXXConversionFunctionName: 6805218893Sdim DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 6806218893Sdim break; 6807218893Sdim 6808218893Sdim case DeclarationName::CXXOperatorName: 6809218893Sdim DNLoc.CXXOperatorName.BeginOpNameLoc 6810218893Sdim = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6811218893Sdim DNLoc.CXXOperatorName.EndOpNameLoc 6812218893Sdim = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6813218893Sdim break; 6814218893Sdim 6815218893Sdim case DeclarationName::CXXLiteralOperatorName: 6816218893Sdim DNLoc.CXXLiteralOperatorName.OpNameLoc 6817218893Sdim = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 6818218893Sdim break; 6819218893Sdim 6820218893Sdim case DeclarationName::Identifier: 6821218893Sdim case DeclarationName::ObjCZeroArgSelector: 6822218893Sdim case DeclarationName::ObjCOneArgSelector: 6823218893Sdim case DeclarationName::ObjCMultiArgSelector: 6824218893Sdim case DeclarationName::CXXUsingDirective: 6825218893Sdim break; 6826218893Sdim } 6827218893Sdim} 6828218893Sdim 6829234353Sdimvoid ASTReader::ReadDeclarationNameInfo(ModuleFile &F, 6830218893Sdim DeclarationNameInfo &NameInfo, 6831218893Sdim const RecordData &Record, unsigned &Idx) { 6832226633Sdim NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 6833218893Sdim NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 6834218893Sdim DeclarationNameLoc DNLoc; 6835218893Sdim ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 6836218893Sdim NameInfo.setInfo(DNLoc); 6837218893Sdim} 6838218893Sdim 6839234353Sdimvoid ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info, 6840218893Sdim const RecordData &Record, unsigned &Idx) { 6841219077Sdim Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 6842218893Sdim unsigned NumTPLists = Record[Idx++]; 6843218893Sdim Info.NumTemplParamLists = NumTPLists; 6844218893Sdim if (NumTPLists) { 6845226633Sdim Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 6846218893Sdim for (unsigned i=0; i != NumTPLists; ++i) 6847218893Sdim Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 6848218893Sdim } 6849218893Sdim} 6850218893Sdim 6851212795SdimTemplateName 6852234353SdimASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record, 6853218893Sdim unsigned &Idx) { 6854218893Sdim TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 6855212795Sdim switch (Kind) { 6856212795Sdim case TemplateName::Template: 6857226633Sdim return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 6858212795Sdim 6859212795Sdim case TemplateName::OverloadedTemplate: { 6860212795Sdim unsigned size = Record[Idx++]; 6861212795Sdim UnresolvedSet<8> Decls; 6862212795Sdim while (size--) 6863226633Sdim Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6864212795Sdim 6865226633Sdim return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 6866212795Sdim } 6867218893Sdim 6868212795Sdim case TemplateName::QualifiedTemplate: { 6869226633Sdim NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6870212795Sdim bool hasTemplKeyword = Record[Idx++]; 6871226633Sdim TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 6872226633Sdim return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 6873212795Sdim } 6874218893Sdim 6875212795Sdim case TemplateName::DependentTemplate: { 6876226633Sdim NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 6877212795Sdim if (Record[Idx++]) // isIdentifier 6878226633Sdim return Context.getDependentTemplateName(NNS, 6879226633Sdim GetIdentifierInfo(F, Record, 6880226633Sdim Idx)); 6881226633Sdim return Context.getDependentTemplateName(NNS, 6882212795Sdim (OverloadedOperatorKind)Record[Idx++]); 6883212795Sdim } 6884224145Sdim 6885224145Sdim case TemplateName::SubstTemplateTemplateParm: { 6886224145Sdim TemplateTemplateParmDecl *param 6887226633Sdim = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6888224145Sdim if (!param) return TemplateName(); 6889224145Sdim TemplateName replacement = ReadTemplateName(F, Record, Idx); 6890226633Sdim return Context.getSubstTemplateTemplateParm(param, replacement); 6891224145Sdim } 6892218893Sdim 6893218893Sdim case TemplateName::SubstTemplateTemplateParmPack: { 6894218893Sdim TemplateTemplateParmDecl *Param 6895226633Sdim = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 6896218893Sdim if (!Param) 6897218893Sdim return TemplateName(); 6898218893Sdim 6899218893Sdim TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 6900218893Sdim if (ArgPack.getKind() != TemplateArgument::Pack) 6901218893Sdim return TemplateName(); 6902218893Sdim 6903226633Sdim return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 6904212795Sdim } 6905218893Sdim } 6906218893Sdim 6907226633Sdim llvm_unreachable("Unhandled template name kind!"); 6908212795Sdim} 6909212795Sdim 6910212795SdimTemplateArgument 6911234353SdimASTReader::ReadTemplateArgument(ModuleFile &F, 6912212795Sdim const RecordData &Record, unsigned &Idx) { 6913218893Sdim TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 6914218893Sdim switch (Kind) { 6915212795Sdim case TemplateArgument::Null: 6916212795Sdim return TemplateArgument(); 6917212795Sdim case TemplateArgument::Type: 6918226633Sdim return TemplateArgument(readType(F, Record, Idx)); 6919243830Sdim case TemplateArgument::Declaration: { 6920243830Sdim ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx); 6921243830Sdim bool ForReferenceParam = Record[Idx++]; 6922243830Sdim return TemplateArgument(D, ForReferenceParam); 6923243830Sdim } 6924243830Sdim case TemplateArgument::NullPtr: 6925243830Sdim return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true); 6926212795Sdim case TemplateArgument::Integral: { 6927212795Sdim llvm::APSInt Value = ReadAPSInt(Record, Idx); 6928226633Sdim QualType T = readType(F, Record, Idx); 6929239462Sdim return TemplateArgument(Context, Value, T); 6930212795Sdim } 6931218893Sdim case TemplateArgument::Template: 6932218893Sdim return TemplateArgument(ReadTemplateName(F, Record, Idx)); 6933218893Sdim case TemplateArgument::TemplateExpansion: { 6934218893Sdim TemplateName Name = ReadTemplateName(F, Record, Idx); 6935249423Sdim Optional<unsigned> NumTemplateExpansions; 6936218893Sdim if (unsigned NumExpansions = Record[Idx++]) 6937218893Sdim NumTemplateExpansions = NumExpansions - 1; 6938218893Sdim return TemplateArgument(Name, NumTemplateExpansions); 6939218893Sdim } 6940212795Sdim case TemplateArgument::Expression: 6941218893Sdim return TemplateArgument(ReadExpr(F)); 6942212795Sdim case TemplateArgument::Pack: { 6943212795Sdim unsigned NumArgs = Record[Idx++]; 6944226633Sdim TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 6945218893Sdim for (unsigned I = 0; I != NumArgs; ++I) 6946218893Sdim Args[I] = ReadTemplateArgument(F, Record, Idx); 6947218893Sdim return TemplateArgument(Args, NumArgs); 6948212795Sdim } 6949212795Sdim } 6950218893Sdim 6951226633Sdim llvm_unreachable("Unhandled template argument kind!"); 6952212795Sdim} 6953212795Sdim 6954212795SdimTemplateParameterList * 6955234353SdimASTReader::ReadTemplateParameterList(ModuleFile &F, 6956218893Sdim const RecordData &Record, unsigned &Idx) { 6957218893Sdim SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 6958218893Sdim SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 6959218893Sdim SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 6960212795Sdim 6961212795Sdim unsigned NumParams = Record[Idx++]; 6962226633Sdim SmallVector<NamedDecl *, 16> Params; 6963212795Sdim Params.reserve(NumParams); 6964212795Sdim while (NumParams--) 6965226633Sdim Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 6966218893Sdim 6967218893Sdim TemplateParameterList* TemplateParams = 6968226633Sdim TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 6969212795Sdim Params.data(), Params.size(), RAngleLoc); 6970212795Sdim return TemplateParams; 6971212795Sdim} 6972212795Sdim 6973212795Sdimvoid 6974212795SdimASTReader:: 6975263508SdimReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs, 6976234353Sdim ModuleFile &F, const RecordData &Record, 6977218893Sdim unsigned &Idx) { 6978212795Sdim unsigned NumTemplateArgs = Record[Idx++]; 6979212795Sdim TemplArgs.reserve(NumTemplateArgs); 6980212795Sdim while (NumTemplateArgs--) 6981218893Sdim TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 6982212795Sdim} 6983212795Sdim 6984212795Sdim/// \brief Read a UnresolvedSet structure. 6985263508Sdimvoid ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set, 6986212795Sdim const RecordData &Record, unsigned &Idx) { 6987212795Sdim unsigned NumDecls = Record[Idx++]; 6988249423Sdim Set.reserve(Context, NumDecls); 6989212795Sdim while (NumDecls--) { 6990263508Sdim DeclID ID = ReadDeclID(F, Record, Idx); 6991212795Sdim AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 6992263508Sdim Set.addLazyDecl(Context, ID, AS); 6993212795Sdim } 6994212795Sdim} 6995212795Sdim 6996212795SdimCXXBaseSpecifier 6997234353SdimASTReader::ReadCXXBaseSpecifier(ModuleFile &F, 6998212795Sdim const RecordData &Record, unsigned &Idx) { 6999212795Sdim bool isVirtual = static_cast<bool>(Record[Idx++]); 7000212795Sdim bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 7001212795Sdim AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 7002218893Sdim bool inheritConstructors = static_cast<bool>(Record[Idx++]); 7003218893Sdim TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 7004218893Sdim SourceRange Range = ReadSourceRange(F, Record, Idx); 7005218893Sdim SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 7006218893Sdim CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 7007218893Sdim EllipsisLoc); 7008218893Sdim Result.setInheritConstructors(inheritConstructors); 7009218893Sdim return Result; 7010212795Sdim} 7011212795Sdim 7012218893Sdimstd::pair<CXXCtorInitializer **, unsigned> 7013234353SdimASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record, 7014218893Sdim unsigned &Idx) { 7015218893Sdim CXXCtorInitializer **CtorInitializers = 0; 7016212795Sdim unsigned NumInitializers = Record[Idx++]; 7017212795Sdim if (NumInitializers) { 7018218893Sdim CtorInitializers 7019226633Sdim = new (Context) CXXCtorInitializer*[NumInitializers]; 7020212795Sdim for (unsigned i=0; i != NumInitializers; ++i) { 7021234353Sdim TypeSourceInfo *TInfo = 0; 7022212795Sdim bool IsBaseVirtual = false; 7023212795Sdim FieldDecl *Member = 0; 7024218893Sdim IndirectFieldDecl *IndirectMember = 0; 7025218893Sdim 7026223017Sdim CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 7027223017Sdim switch (Type) { 7028234353Sdim case CTOR_INITIALIZER_BASE: 7029234353Sdim TInfo = GetTypeSourceInfo(F, Record, Idx); 7030212795Sdim IsBaseVirtual = Record[Idx++]; 7031223017Sdim break; 7032234353Sdim 7033234353Sdim case CTOR_INITIALIZER_DELEGATING: 7034234353Sdim TInfo = GetTypeSourceInfo(F, Record, Idx); 7035223017Sdim break; 7036223017Sdim 7037223017Sdim case CTOR_INITIALIZER_MEMBER: 7038226633Sdim Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 7039223017Sdim break; 7040223017Sdim 7041223017Sdim case CTOR_INITIALIZER_INDIRECT_MEMBER: 7042226633Sdim IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 7043223017Sdim break; 7044212795Sdim } 7045223017Sdim 7046218893Sdim SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 7047218893Sdim Expr *Init = ReadExpr(F); 7048218893Sdim SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 7049218893Sdim SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 7050212795Sdim bool IsWritten = Record[Idx++]; 7051212795Sdim unsigned SourceOrderOrNumArrayIndices; 7052226633Sdim SmallVector<VarDecl *, 8> Indices; 7053212795Sdim if (IsWritten) { 7054212795Sdim SourceOrderOrNumArrayIndices = Record[Idx++]; 7055212795Sdim } else { 7056212795Sdim SourceOrderOrNumArrayIndices = Record[Idx++]; 7057212795Sdim Indices.reserve(SourceOrderOrNumArrayIndices); 7058212795Sdim for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 7059226633Sdim Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 7060212795Sdim } 7061218893Sdim 7062218893Sdim CXXCtorInitializer *BOMInit; 7063223017Sdim if (Type == CTOR_INITIALIZER_BASE) { 7064234353Sdim BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, IsBaseVirtual, 7065218893Sdim LParenLoc, Init, RParenLoc, 7066218893Sdim MemberOrEllipsisLoc); 7067223017Sdim } else if (Type == CTOR_INITIALIZER_DELEGATING) { 7068234353Sdim BOMInit = new (Context) CXXCtorInitializer(Context, TInfo, LParenLoc, 7069234353Sdim Init, RParenLoc); 7070212795Sdim } else if (IsWritten) { 7071218893Sdim if (Member) 7072226633Sdim BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 7073218893Sdim LParenLoc, Init, RParenLoc); 7074218893Sdim else 7075226633Sdim BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 7076218893Sdim MemberOrEllipsisLoc, LParenLoc, 7077218893Sdim Init, RParenLoc); 7078212795Sdim } else { 7079263508Sdim if (IndirectMember) { 7080263508Sdim assert(Indices.empty() && "Indirect field improperly initialized"); 7081263508Sdim BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 7082263508Sdim MemberOrEllipsisLoc, LParenLoc, 7083263508Sdim Init, RParenLoc); 7084263508Sdim } else { 7085263508Sdim BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 7086263508Sdim LParenLoc, Init, RParenLoc, 7087263508Sdim Indices.data(), Indices.size()); 7088263508Sdim } 7089212795Sdim } 7090212795Sdim 7091218893Sdim if (IsWritten) 7092218893Sdim BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 7093218893Sdim CtorInitializers[i] = BOMInit; 7094212795Sdim } 7095212795Sdim } 7096212795Sdim 7097218893Sdim return std::make_pair(CtorInitializers, NumInitializers); 7098212795Sdim} 7099212795Sdim 7100212795SdimNestedNameSpecifier * 7101234353SdimASTReader::ReadNestedNameSpecifier(ModuleFile &F, 7102226633Sdim const RecordData &Record, unsigned &Idx) { 7103212795Sdim unsigned N = Record[Idx++]; 7104212795Sdim NestedNameSpecifier *NNS = 0, *Prev = 0; 7105212795Sdim for (unsigned I = 0; I != N; ++I) { 7106212795Sdim NestedNameSpecifier::SpecifierKind Kind 7107212795Sdim = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 7108212795Sdim switch (Kind) { 7109212795Sdim case NestedNameSpecifier::Identifier: { 7110226633Sdim IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 7111226633Sdim NNS = NestedNameSpecifier::Create(Context, Prev, II); 7112212795Sdim break; 7113212795Sdim } 7114212795Sdim 7115212795Sdim case NestedNameSpecifier::Namespace: { 7116226633Sdim NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 7117226633Sdim NNS = NestedNameSpecifier::Create(Context, Prev, NS); 7118212795Sdim break; 7119212795Sdim } 7120212795Sdim 7121219077Sdim case NestedNameSpecifier::NamespaceAlias: { 7122226633Sdim NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 7123226633Sdim NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 7124219077Sdim break; 7125219077Sdim } 7126219077Sdim 7127212795Sdim case NestedNameSpecifier::TypeSpec: 7128212795Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 7129226633Sdim const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 7130218893Sdim if (!T) 7131218893Sdim return 0; 7132218893Sdim 7133212795Sdim bool Template = Record[Idx++]; 7134226633Sdim NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 7135212795Sdim break; 7136212795Sdim } 7137212795Sdim 7138212795Sdim case NestedNameSpecifier::Global: { 7139226633Sdim NNS = NestedNameSpecifier::GlobalSpecifier(Context); 7140212795Sdim // No associated value, and there can't be a prefix. 7141212795Sdim break; 7142212795Sdim } 7143212795Sdim } 7144212795Sdim Prev = NNS; 7145212795Sdim } 7146212795Sdim return NNS; 7147212795Sdim} 7148212795Sdim 7149219077SdimNestedNameSpecifierLoc 7150234353SdimASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record, 7151219077Sdim unsigned &Idx) { 7152219077Sdim unsigned N = Record[Idx++]; 7153221345Sdim NestedNameSpecifierLocBuilder Builder; 7154219077Sdim for (unsigned I = 0; I != N; ++I) { 7155219077Sdim NestedNameSpecifier::SpecifierKind Kind 7156219077Sdim = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 7157219077Sdim switch (Kind) { 7158219077Sdim case NestedNameSpecifier::Identifier: { 7159226633Sdim IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 7160219077Sdim SourceRange Range = ReadSourceRange(F, Record, Idx); 7161226633Sdim Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 7162219077Sdim break; 7163219077Sdim } 7164219077Sdim 7165219077Sdim case NestedNameSpecifier::Namespace: { 7166226633Sdim NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 7167219077Sdim SourceRange Range = ReadSourceRange(F, Record, Idx); 7168226633Sdim Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 7169219077Sdim break; 7170219077Sdim } 7171219077Sdim 7172219077Sdim case NestedNameSpecifier::NamespaceAlias: { 7173226633Sdim NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 7174219077Sdim SourceRange Range = ReadSourceRange(F, Record, Idx); 7175226633Sdim Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 7176219077Sdim break; 7177219077Sdim } 7178219077Sdim 7179219077Sdim case NestedNameSpecifier::TypeSpec: 7180219077Sdim case NestedNameSpecifier::TypeSpecWithTemplate: { 7181219077Sdim bool Template = Record[Idx++]; 7182219077Sdim TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 7183219077Sdim if (!T) 7184219077Sdim return NestedNameSpecifierLoc(); 7185221345Sdim SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 7186219077Sdim 7187221345Sdim // FIXME: 'template' keyword location not saved anywhere, so we fake it. 7188226633Sdim Builder.Extend(Context, 7189221345Sdim Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 7190221345Sdim T->getTypeLoc(), ColonColonLoc); 7191219077Sdim break; 7192219077Sdim } 7193219077Sdim 7194219077Sdim case NestedNameSpecifier::Global: { 7195219077Sdim SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 7196226633Sdim Builder.MakeGlobal(Context, ColonColonLoc); 7197219077Sdim break; 7198219077Sdim } 7199219077Sdim } 7200219077Sdim } 7201219077Sdim 7202226633Sdim return Builder.getWithLocInContext(Context); 7203219077Sdim} 7204219077Sdim 7205212795SdimSourceRange 7206234353SdimASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record, 7207218893Sdim unsigned &Idx) { 7208218893Sdim SourceLocation beg = ReadSourceLocation(F, Record, Idx); 7209218893Sdim SourceLocation end = ReadSourceLocation(F, Record, Idx); 7210212795Sdim return SourceRange(beg, end); 7211212795Sdim} 7212212795Sdim 7213212795Sdim/// \brief Read an integral value 7214212795Sdimllvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 7215212795Sdim unsigned BitWidth = Record[Idx++]; 7216212795Sdim unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 7217212795Sdim llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 7218212795Sdim Idx += NumWords; 7219212795Sdim return Result; 7220212795Sdim} 7221212795Sdim 7222212795Sdim/// \brief Read a signed integral value 7223212795Sdimllvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 7224212795Sdim bool isUnsigned = Record[Idx++]; 7225212795Sdim return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 7226212795Sdim} 7227212795Sdim 7228212795Sdim/// \brief Read a floating-point value 7229249423Sdimllvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, 7230249423Sdim const llvm::fltSemantics &Sem, 7231249423Sdim unsigned &Idx) { 7232249423Sdim return llvm::APFloat(Sem, ReadAPInt(Record, Idx)); 7233212795Sdim} 7234212795Sdim 7235212795Sdim// \brief Read a string 7236212795Sdimstd::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 7237212795Sdim unsigned Len = Record[Idx++]; 7238212795Sdim std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 7239212795Sdim Idx += Len; 7240212795Sdim return Result; 7241212795Sdim} 7242212795Sdim 7243221345SdimVersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 7244221345Sdim unsigned &Idx) { 7245221345Sdim unsigned Major = Record[Idx++]; 7246221345Sdim unsigned Minor = Record[Idx++]; 7247221345Sdim unsigned Subminor = Record[Idx++]; 7248221345Sdim if (Minor == 0) 7249221345Sdim return VersionTuple(Major); 7250221345Sdim if (Subminor == 0) 7251221345Sdim return VersionTuple(Major, Minor - 1); 7252221345Sdim return VersionTuple(Major, Minor - 1, Subminor - 1); 7253221345Sdim} 7254221345Sdim 7255234353SdimCXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F, 7256226633Sdim const RecordData &Record, 7257212795Sdim unsigned &Idx) { 7258226633Sdim CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 7259226633Sdim return CXXTemporary::Create(Context, Decl); 7260212795Sdim} 7261212795Sdim 7262212795SdimDiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 7263263508Sdim return Diag(CurrentImportLoc, DiagID); 7264212795Sdim} 7265212795Sdim 7266212795SdimDiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 7267218893Sdim return Diags.Report(Loc, DiagID); 7268212795Sdim} 7269212795Sdim 7270212795Sdim/// \brief Retrieve the identifier table associated with the 7271212795Sdim/// preprocessor. 7272212795SdimIdentifierTable &ASTReader::getIdentifierTable() { 7273226633Sdim return PP.getIdentifierTable(); 7274212795Sdim} 7275212795Sdim 7276212795Sdim/// \brief Record that the given ID maps to the given switch-case 7277212795Sdim/// statement. 7278212795Sdimvoid ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 7279239462Sdim assert((*CurrSwitchCaseStmts)[ID] == 0 && 7280239462Sdim "Already have a SwitchCase with this ID"); 7281239462Sdim (*CurrSwitchCaseStmts)[ID] = SC; 7282212795Sdim} 7283212795Sdim 7284212795Sdim/// \brief Retrieve the switch-case statement with the given ID. 7285212795SdimSwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 7286239462Sdim assert((*CurrSwitchCaseStmts)[ID] != 0 && "No SwitchCase with this ID"); 7287239462Sdim return (*CurrSwitchCaseStmts)[ID]; 7288212795Sdim} 7289212795Sdim 7290218893Sdimvoid ASTReader::ClearSwitchCaseIDs() { 7291239462Sdim CurrSwitchCaseStmts->clear(); 7292212795Sdim} 7293212795Sdim 7294239462Sdimvoid ASTReader::ReadComments() { 7295239462Sdim std::vector<RawComment *> Comments; 7296249423Sdim for (SmallVectorImpl<std::pair<BitstreamCursor, 7297239462Sdim serialization::ModuleFile *> >::iterator 7298239462Sdim I = CommentsCursors.begin(), 7299239462Sdim E = CommentsCursors.end(); 7300239462Sdim I != E; ++I) { 7301249423Sdim BitstreamCursor &Cursor = I->first; 7302239462Sdim serialization::ModuleFile &F = *I->second; 7303239462Sdim SavedStreamPosition SavedPosition(Cursor); 7304239462Sdim 7305239462Sdim RecordData Record; 7306239462Sdim while (true) { 7307249423Sdim llvm::BitstreamEntry Entry = 7308249423Sdim Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd); 7309249423Sdim 7310249423Sdim switch (Entry.Kind) { 7311249423Sdim case llvm::BitstreamEntry::SubBlock: // Handled for us already. 7312249423Sdim case llvm::BitstreamEntry::Error: 7313249423Sdim Error("malformed block record in AST file"); 7314249423Sdim return; 7315249423Sdim case llvm::BitstreamEntry::EndBlock: 7316249423Sdim goto NextCursor; 7317249423Sdim case llvm::BitstreamEntry::Record: 7318249423Sdim // The interesting case. 7319239462Sdim break; 7320239462Sdim } 7321239462Sdim 7322239462Sdim // Read a record. 7323239462Sdim Record.clear(); 7324249423Sdim switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) { 7325239462Sdim case COMMENTS_RAW_COMMENT: { 7326239462Sdim unsigned Idx = 0; 7327239462Sdim SourceRange SR = ReadSourceRange(F, Record, Idx); 7328239462Sdim RawComment::CommentKind Kind = 7329239462Sdim (RawComment::CommentKind) Record[Idx++]; 7330239462Sdim bool IsTrailingComment = Record[Idx++]; 7331239462Sdim bool IsAlmostTrailingComment = Record[Idx++]; 7332251662Sdim Comments.push_back(new (Context) RawComment( 7333251662Sdim SR, Kind, IsTrailingComment, IsAlmostTrailingComment, 7334251662Sdim Context.getLangOpts().CommentOpts.ParseAllComments)); 7335239462Sdim break; 7336239462Sdim } 7337239462Sdim } 7338239462Sdim } 7339249423Sdim NextCursor:; 7340239462Sdim } 7341239462Sdim Context.Comments.addCommentsToFront(Comments); 7342239462Sdim} 7343239462Sdim 7344234353Sdimvoid ASTReader::finishPendingActions() { 7345243830Sdim while (!PendingIdentifierInfos.empty() || !PendingDeclChains.empty() || 7346263508Sdim !PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() || 7347263508Sdim !PendingOdrMergeChecks.empty()) { 7348212795Sdim // If any identifiers with corresponding top-level declarations have 7349212795Sdim // been loaded, load those declarations now. 7350263508Sdim typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> > 7351263508Sdim TopLevelDeclsMap; 7352263508Sdim TopLevelDeclsMap TopLevelDecls; 7353263508Sdim 7354212795Sdim while (!PendingIdentifierInfos.empty()) { 7355249423Sdim // FIXME: std::move 7356249423Sdim IdentifierInfo *II = PendingIdentifierInfos.back().first; 7357249423Sdim SmallVector<uint32_t, 4> DeclIDs = PendingIdentifierInfos.back().second; 7358249423Sdim PendingIdentifierInfos.pop_back(); 7359249423Sdim 7360249423Sdim SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]); 7361212795Sdim } 7362234353Sdim 7363234353Sdim // Load pending declaration chains. 7364234353Sdim for (unsigned I = 0; I != PendingDeclChains.size(); ++I) { 7365234353Sdim loadPendingDeclChain(PendingDeclChains[I]); 7366234353Sdim PendingDeclChainsKnown.erase(PendingDeclChains[I]); 7367234353Sdim } 7368234353Sdim PendingDeclChains.clear(); 7369243830Sdim 7370249423Sdim // Make the most recent of the top-level declarations visible. 7371263508Sdim for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(), 7372263508Sdim TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) { 7373249423Sdim IdentifierInfo *II = TLD->first; 7374249423Sdim for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) { 7375251662Sdim pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II); 7376249423Sdim } 7377249423Sdim } 7378249423Sdim 7379243830Sdim // Load any pending macro definitions. 7380243830Sdim for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) { 7381249423Sdim IdentifierInfo *II = PendingMacroIDs.begin()[I].first; 7382249423Sdim SmallVector<PendingMacroInfo, 2> GlobalIDs; 7383249423Sdim GlobalIDs.swap(PendingMacroIDs.begin()[I].second); 7384249423Sdim // Initialize the macro history from chained-PCHs ahead of module imports. 7385243830Sdim for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; 7386243830Sdim ++IDIdx) { 7387249423Sdim const PendingMacroInfo &Info = GlobalIDs[IDIdx]; 7388249423Sdim if (Info.M->Kind != MK_Module) 7389249423Sdim resolvePendingMacro(II, Info); 7390243830Sdim } 7391249423Sdim // Handle module imports. 7392249423Sdim for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs; 7393249423Sdim ++IDIdx) { 7394249423Sdim const PendingMacroInfo &Info = GlobalIDs[IDIdx]; 7395249423Sdim if (Info.M->Kind == MK_Module) 7396249423Sdim resolvePendingMacro(II, Info); 7397249423Sdim } 7398243830Sdim } 7399243830Sdim PendingMacroIDs.clear(); 7400249423Sdim 7401249423Sdim // Wire up the DeclContexts for Decls that we delayed setting until 7402249423Sdim // recursive loading is completed. 7403249423Sdim while (!PendingDeclContextInfos.empty()) { 7404249423Sdim PendingDeclContextInfo Info = PendingDeclContextInfos.front(); 7405249423Sdim PendingDeclContextInfos.pop_front(); 7406249423Sdim DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC)); 7407249423Sdim DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC)); 7408249423Sdim Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext()); 7409249423Sdim } 7410263508Sdim 7411263508Sdim // For each declaration from a merged context, check that the canonical 7412263508Sdim // definition of that context also contains a declaration of the same 7413263508Sdim // entity. 7414263508Sdim while (!PendingOdrMergeChecks.empty()) { 7415263508Sdim NamedDecl *D = PendingOdrMergeChecks.pop_back_val(); 7416263508Sdim 7417263508Sdim // FIXME: Skip over implicit declarations for now. This matters for things 7418263508Sdim // like implicitly-declared special member functions. This isn't entirely 7419263508Sdim // correct; we can end up with multiple unmerged declarations of the same 7420263508Sdim // implicit entity. 7421263508Sdim if (D->isImplicit()) 7422263508Sdim continue; 7423263508Sdim 7424263508Sdim DeclContext *CanonDef = D->getDeclContext(); 7425263508Sdim DeclContext::lookup_result R = CanonDef->lookup(D->getDeclName()); 7426263508Sdim 7427263508Sdim bool Found = false; 7428263508Sdim const Decl *DCanon = D->getCanonicalDecl(); 7429263508Sdim 7430263508Sdim llvm::SmallVector<const NamedDecl*, 4> Candidates; 7431263508Sdim for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); 7432263508Sdim !Found && I != E; ++I) { 7433263508Sdim for (Decl::redecl_iterator RI = (*I)->redecls_begin(), 7434263508Sdim RE = (*I)->redecls_end(); 7435263508Sdim RI != RE; ++RI) { 7436263508Sdim if ((*RI)->getLexicalDeclContext() == CanonDef) { 7437263508Sdim // This declaration is present in the canonical definition. If it's 7438263508Sdim // in the same redecl chain, it's the one we're looking for. 7439263508Sdim if ((*RI)->getCanonicalDecl() == DCanon) 7440263508Sdim Found = true; 7441263508Sdim else 7442263508Sdim Candidates.push_back(cast<NamedDecl>(*RI)); 7443263508Sdim break; 7444263508Sdim } 7445263508Sdim } 7446263508Sdim } 7447263508Sdim 7448263508Sdim if (!Found) { 7449263508Sdim D->setInvalidDecl(); 7450263508Sdim 7451263508Sdim Module *CanonDefModule = cast<Decl>(CanonDef)->getOwningModule(); 7452263508Sdim Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl) 7453263508Sdim << D << D->getOwningModule()->getFullModuleName() 7454263508Sdim << CanonDef << !CanonDefModule 7455263508Sdim << (CanonDefModule ? CanonDefModule->getFullModuleName() : ""); 7456263508Sdim 7457263508Sdim if (Candidates.empty()) 7458263508Sdim Diag(cast<Decl>(CanonDef)->getLocation(), 7459263508Sdim diag::note_module_odr_violation_no_possible_decls) << D; 7460263508Sdim else { 7461263508Sdim for (unsigned I = 0, N = Candidates.size(); I != N; ++I) 7462263508Sdim Diag(Candidates[I]->getLocation(), 7463263508Sdim diag::note_module_odr_violation_possible_decl) 7464263508Sdim << Candidates[I]; 7465263508Sdim } 7466263508Sdim } 7467263508Sdim } 7468234353Sdim } 7469234353Sdim 7470234353Sdim // If we deserialized any C++ or Objective-C class definitions, any 7471234353Sdim // Objective-C protocol definitions, or any redeclarable templates, make sure 7472234353Sdim // that all redeclarations point to the definitions. Note that this can only 7473234353Sdim // happen now, after the redeclaration chains have been fully wired. 7474234353Sdim for (llvm::SmallPtrSet<Decl *, 4>::iterator D = PendingDefinitions.begin(), 7475234353Sdim DEnd = PendingDefinitions.end(); 7476234353Sdim D != DEnd; ++D) { 7477234353Sdim if (TagDecl *TD = dyn_cast<TagDecl>(*D)) { 7478234353Sdim if (const TagType *TagT = dyn_cast<TagType>(TD->TypeForDecl)) { 7479234353Sdim // Make sure that the TagType points at the definition. 7480234353Sdim const_cast<TagType*>(TagT)->decl = TD; 7481234353Sdim } 7482234353Sdim 7483234353Sdim if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(*D)) { 7484234353Sdim for (CXXRecordDecl::redecl_iterator R = RD->redecls_begin(), 7485234353Sdim REnd = RD->redecls_end(); 7486234353Sdim R != REnd; ++R) 7487234353Sdim cast<CXXRecordDecl>(*R)->DefinitionData = RD->DefinitionData; 7488234353Sdim 7489234353Sdim } 7490212795Sdim 7491234353Sdim continue; 7492218893Sdim } 7493234353Sdim 7494234353Sdim if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(*D)) { 7495234353Sdim // Make sure that the ObjCInterfaceType points at the definition. 7496234353Sdim const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl)) 7497234353Sdim ->Decl = ID; 7498234353Sdim 7499234353Sdim for (ObjCInterfaceDecl::redecl_iterator R = ID->redecls_begin(), 7500234353Sdim REnd = ID->redecls_end(); 7501234353Sdim R != REnd; ++R) 7502234353Sdim R->Data = ID->Data; 7503234353Sdim 7504234353Sdim continue; 7505234353Sdim } 7506234353Sdim 7507234353Sdim if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(*D)) { 7508234353Sdim for (ObjCProtocolDecl::redecl_iterator R = PD->redecls_begin(), 7509234353Sdim REnd = PD->redecls_end(); 7510234353Sdim R != REnd; ++R) 7511234353Sdim R->Data = PD->Data; 7512234353Sdim 7513234353Sdim continue; 7514234353Sdim } 7515234353Sdim 7516234353Sdim RedeclarableTemplateDecl *RTD 7517234353Sdim = cast<RedeclarableTemplateDecl>(*D)->getCanonicalDecl(); 7518234353Sdim for (RedeclarableTemplateDecl::redecl_iterator R = RTD->redecls_begin(), 7519234353Sdim REnd = RTD->redecls_end(); 7520234353Sdim R != REnd; ++R) 7521243830Sdim R->Common = RTD->Common; 7522234353Sdim } 7523234353Sdim PendingDefinitions.clear(); 7524243830Sdim 7525243830Sdim // Load the bodies of any functions or methods we've encountered. We do 7526243830Sdim // this now (delayed) so that we can be sure that the declaration chains 7527243830Sdim // have been fully wired up. 7528243830Sdim for (PendingBodiesMap::iterator PB = PendingBodies.begin(), 7529243830Sdim PBEnd = PendingBodies.end(); 7530243830Sdim PB != PBEnd; ++PB) { 7531243830Sdim if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) { 7532243830Sdim // FIXME: Check for =delete/=default? 7533243830Sdim // FIXME: Complain about ODR violations here? 7534243830Sdim if (!getContext().getLangOpts().Modules || !FD->hasBody()) 7535243830Sdim FD->setLazyBody(PB->second); 7536243830Sdim continue; 7537243830Sdim } 7538243830Sdim 7539243830Sdim ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first); 7540243830Sdim if (!getContext().getLangOpts().Modules || !MD->hasBody()) 7541243830Sdim MD->setLazyBody(PB->second); 7542243830Sdim } 7543243830Sdim PendingBodies.clear(); 7544234353Sdim} 7545218893Sdim 7546234353Sdimvoid ASTReader::FinishedDeserializing() { 7547234353Sdim assert(NumCurrentElementsDeserializing && 7548234353Sdim "FinishedDeserializing not paired with StartedDeserializing"); 7549234353Sdim if (NumCurrentElementsDeserializing == 1) { 7550234353Sdim // We decrease NumCurrentElementsDeserializing only after pending actions 7551234353Sdim // are finished, to avoid recursively re-calling finishPendingActions(). 7552234353Sdim finishPendingActions(); 7553234353Sdim } 7554234353Sdim --NumCurrentElementsDeserializing; 7555218893Sdim 7556234353Sdim if (NumCurrentElementsDeserializing == 0 && 7557234353Sdim Consumer && !PassingDeclsToConsumer) { 7558234353Sdim // Guard variable to avoid recursively redoing the process of passing 7559234353Sdim // decls to consumer. 7560234353Sdim SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer, 7561234353Sdim true); 7562234353Sdim 7563234353Sdim while (!InterestingDecls.empty()) { 7564234353Sdim // We are not in recursive loading, so it's safe to pass the "interesting" 7565234353Sdim // decls to the consumer. 7566234353Sdim Decl *D = InterestingDecls.front(); 7567234353Sdim InterestingDecls.pop_front(); 7568234353Sdim PassInterestingDeclToConsumer(D); 7569234353Sdim } 7570212795Sdim } 7571212795Sdim} 7572212795Sdim 7573251662Sdimvoid ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) { 7574263508Sdim D = D->getMostRecentDecl(); 7575251662Sdim 7576251662Sdim if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) { 7577251662Sdim SemaObj->TUScope->AddDecl(D); 7578251662Sdim } else if (SemaObj->TUScope) { 7579251662Sdim // Adding the decl to IdResolver may have failed because it was already in 7580251662Sdim // (even though it was not added in scope). If it is already in, make sure 7581251662Sdim // it gets in the scope as well. 7582251662Sdim if (std::find(SemaObj->IdResolver.begin(Name), 7583251662Sdim SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end()) 7584251662Sdim SemaObj->TUScope->AddDecl(D); 7585251662Sdim } 7586251662Sdim} 7587251662Sdim 7588226633SdimASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 7589226633Sdim StringRef isysroot, bool DisableValidation, 7590249423Sdim bool AllowASTWithCompilerErrors, bool UseGlobalIndex) 7591212795Sdim : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 7592212795Sdim SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 7593226633Sdim Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 7594243830Sdim Consumer(0), ModuleMgr(PP.getFileManager()), 7595243830Sdim isysroot(isysroot), DisableValidation(DisableValidation), 7596249423Sdim AllowASTWithCompilerErrors(AllowASTWithCompilerErrors), 7597249423Sdim UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false), 7598239462Sdim CurrentGeneration(0), CurrSwitchCaseStmts(&SwitchCaseStmts), 7599226633Sdim NumSLocEntriesRead(0), TotalNumSLocEntries(0), 7600249423Sdim NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 7601249423Sdim TotalNumMacros(0), NumIdentifierLookups(0), NumIdentifierLookupHits(0), 7602249423Sdim NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 7603249423Sdim NumMethodPoolLookups(0), NumMethodPoolHits(0), 7604249423Sdim NumMethodPoolTableLookups(0), NumMethodPoolTableHits(0), 7605249423Sdim TotalNumMethodPoolEntries(0), 7606218893Sdim NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 7607226633Sdim NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 7608226633Sdim TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 7609234353Sdim PassingDeclsToConsumer(false), 7610263508Sdim NumCXXBaseSpecifiersLoaded(0), ReadingKind(Read_None) 7611218893Sdim{ 7612226633Sdim SourceMgr.setExternalSLocEntrySource(this); 7613212795Sdim} 7614212795Sdim 7615212795SdimASTReader::~ASTReader() { 7616212795Sdim for (DeclContextVisibleUpdatesPending::iterator 7617212795Sdim I = PendingVisibleUpdates.begin(), 7618212795Sdim E = PendingVisibleUpdates.end(); 7619212795Sdim I != E; ++I) { 7620212795Sdim for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 7621212795Sdim F = I->second.end(); 7622212795Sdim J != F; ++J) 7623234982Sdim delete J->first; 7624212795Sdim } 7625212795Sdim} 7626