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