ASTReader.cpp revision eabdd6716dfe777a28435276fe6c89af77608b11
11e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)//===--- ASTReader.cpp - AST File Reader ------------------------*- C++ -*-===// 21e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// 31e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// The LLVM Compiler Infrastructure 41e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// 51e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// This file is distributed under the University of Illinois Open Source 61e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// License. See LICENSE.TXT for details. 7116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch// 81e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)//===----------------------------------------------------------------------===// 91e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// 101e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// This file defines the ASTReader class, which reads AST files. 111e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)// 121e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)//===----------------------------------------------------------------------===// 131e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 1423730a6e56a168d1879203e4b3819bb36e3d8f1fTorne (Richard Coles)#include "clang/Serialization/ASTReader.h" 155d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#include "clang/Serialization/ASTDeserializationListener.h" 161e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/Serialization/ModuleManager.h" 176e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include "ASTCommon.h" 186e8cce623b6e4fe0c9e4af605d675dd9d0338c38Torne (Richard Coles)#include "ASTReaderInternals.h" 195d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#include "clang/Frontend/FrontendDiagnostic.h" 20f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles)#include "clang/Frontend/Utils.h" 211e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/Sema/Sema.h" 221e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/Sema/Scope.h" 231e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/ASTConsumer.h" 241e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/ASTContext.h" 251e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/DeclTemplate.h" 261e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/Expr.h" 271e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/ExprCXX.h" 281e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/NestedNameSpecifier.h" 291e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/AST/Type.h" 300f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles)#include "clang/AST/TypeLocVisitor.h" 310f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles)#include "clang/Lex/MacroInfo.h" 320f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles)#include "clang/Lex/PreprocessingRecord.h" 331e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/Lex/Preprocessor.h" 341e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/Lex/HeaderSearch.h" 351e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "clang/Basic/OnDiskHashTable.h" 36116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "clang/Basic/SourceManager.h" 37116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "clang/Basic/SourceManagerInternals.h" 38116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "clang/Basic/FileManager.h" 39116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "clang/Basic/FileSystemStatCache.h" 405f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#include "clang/Basic/TargetInfo.h" 415f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#include "clang/Basic/Version.h" 425f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)#include "clang/Basic/VersionTuple.h" 43116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "llvm/ADT/StringExtras.h" 44116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#include "llvm/Bitcode/BitstreamReader.h" 45cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)#include "llvm/Support/MemoryBuffer.h" 461e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "llvm/Support/ErrorHandling.h" 471e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "llvm/Support/FileSystem.h" 481e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "llvm/Support/Path.h" 491e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include "llvm/Support/system_error.h" 50f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles)#include <algorithm> 511e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#include <iterator> 52cedac228d2dd51db4b79ea1e72c7f249408ee061Torne (Richard Coles)#include <cstdio> 53f2477e01787aa58f445919b809d89e252beef54fTorne (Richard Coles)#include <sys/stat.h> 541e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 555f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)using namespace clang; 565f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)using namespace clang::serialization; 575f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)using namespace clang::serialization::reader; 585f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles) 595f1c94371a64b3196d4be9466099bb892df9b88eTorne (Richard Coles)//===----------------------------------------------------------------------===// 605d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)// PCH validator implementation 610f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles)//===----------------------------------------------------------------------===// 620f1bc08d4cfcc34181b0b5cbf065c40f687bf740Torne (Richard Coles) 631e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)ASTReaderListener::~ASTReaderListener() {} 641e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 651e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)bool 661e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { 671e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) const LangOptions &PPLangOpts = PP.getLangOptions(); 681e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 69116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#define LANGOPT(Name, Bits, Default, Description) \ 7046d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) if (PPLangOpts.Name != LangOpts.Name) { \ 715d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) Reader.Diag(diag::err_pch_langopt_mismatch) \ 7246d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) << Description << LangOpts.Name << PPLangOpts.Name; \ 735d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) return true; \ 745d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) } 755d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) 765d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles)#define VALUE_LANGOPT(Name, Bits, Default, Description) \ 7746d4c2bc3267f3f028f39e7e311b0f89aba2e4fdTorne (Richard Coles) if (PPLangOpts.Name != LangOpts.Name) { \ 785d1f7b1de12d16ceb2c938c56701a3e8bfa558f7Torne (Richard Coles) Reader.Diag(diag::err_pch_langopt_value_mismatch) \ 791e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) << Description; \ 80116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch return true; \ 81116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch} 82116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch 83116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 84116680a4aac90f2aa7413d9095a592090648e557Ben Murdoch if (PPLangOpts.get##Name() != LangOpts.get##Name()) { \ 851e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) Reader.Diag(diag::err_pch_langopt_value_mismatch) \ 861e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) << Description; \ 871e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) return true; \ 881e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) } 891e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles) 901e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#define BENIGN_LANGOPT(Name, Bits, Default, Description) 911e9bf3e0803691d0a228da41fc608347b6db4340Torne (Richard Coles)#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) 92#include "clang/Basic/LangOptions.def" 93 94 return false; 95} 96 97bool PCHValidator::ReadTargetTriple(StringRef Triple) { 98 if (Triple == PP.getTargetInfo().getTriple().str()) 99 return false; 100 101 Reader.Diag(diag::warn_pch_target_triple) 102 << Triple << PP.getTargetInfo().getTriple().str(); 103 return true; 104} 105 106namespace { 107 struct EmptyStringRef { 108 bool operator ()(StringRef r) const { return r.empty(); } 109 }; 110 struct EmptyBlock { 111 bool operator ()(const PCHPredefinesBlock &r) const {return r.Data.empty();} 112 }; 113} 114 115static bool EqualConcatenations(SmallVector<StringRef, 2> L, 116 PCHPredefinesBlocks R) { 117 // First, sum up the lengths. 118 unsigned LL = 0, RL = 0; 119 for (unsigned I = 0, N = L.size(); I != N; ++I) { 120 LL += L[I].size(); 121 } 122 for (unsigned I = 0, N = R.size(); I != N; ++I) { 123 RL += R[I].Data.size(); 124 } 125 if (LL != RL) 126 return false; 127 if (LL == 0 && RL == 0) 128 return true; 129 130 // Kick out empty parts, they confuse the algorithm below. 131 L.erase(std::remove_if(L.begin(), L.end(), EmptyStringRef()), L.end()); 132 R.erase(std::remove_if(R.begin(), R.end(), EmptyBlock()), R.end()); 133 134 // Do it the hard way. At this point, both vectors must be non-empty. 135 StringRef LR = L[0], RR = R[0].Data; 136 unsigned LI = 0, RI = 0, LN = L.size(), RN = R.size(); 137 (void) RN; 138 for (;;) { 139 // Compare the current pieces. 140 if (LR.size() == RR.size()) { 141 // If they're the same length, it's pretty easy. 142 if (LR != RR) 143 return false; 144 // Both pieces are done, advance. 145 ++LI; 146 ++RI; 147 // If either string is done, they're both done, since they're the same 148 // length. 149 if (LI == LN) { 150 assert(RI == RN && "Strings not the same length after all?"); 151 return true; 152 } 153 LR = L[LI]; 154 RR = R[RI].Data; 155 } else if (LR.size() < RR.size()) { 156 // Right piece is longer. 157 if (!RR.startswith(LR)) 158 return false; 159 ++LI; 160 assert(LI != LN && "Strings not the same length after all?"); 161 RR = RR.substr(LR.size()); 162 LR = L[LI]; 163 } else { 164 // Left piece is longer. 165 if (!LR.startswith(RR)) 166 return false; 167 ++RI; 168 assert(RI != RN && "Strings not the same length after all?"); 169 LR = LR.substr(RR.size()); 170 RR = R[RI].Data; 171 } 172 } 173} 174 175static std::pair<FileID, StringRef::size_type> 176FindMacro(const PCHPredefinesBlocks &Buffers, StringRef MacroDef) { 177 std::pair<FileID, StringRef::size_type> Res; 178 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) { 179 Res.second = Buffers[I].Data.find(MacroDef); 180 if (Res.second != StringRef::npos) { 181 Res.first = Buffers[I].BufferID; 182 break; 183 } 184 } 185 return Res; 186} 187 188bool PCHValidator::ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers, 189 StringRef OriginalFileName, 190 std::string &SuggestedPredefines, 191 FileManager &FileMgr) { 192 // We are in the context of an implicit include, so the predefines buffer will 193 // have a #include entry for the PCH file itself (as normalized by the 194 // preprocessor initialization). Find it and skip over it in the checking 195 // below. 196 llvm::SmallString<256> PCHInclude; 197 PCHInclude += "#include \""; 198 PCHInclude += NormalizeDashIncludePath(OriginalFileName, FileMgr); 199 PCHInclude += "\"\n"; 200 std::pair<StringRef,StringRef> Split = 201 StringRef(PP.getPredefines()).split(PCHInclude.str()); 202 StringRef Left = Split.first, Right = Split.second; 203 if (Left == PP.getPredefines()) { 204 Error("Missing PCH include entry!"); 205 return true; 206 } 207 208 // If the concatenation of all the PCH buffers is equal to the adjusted 209 // command line, we're done. 210 SmallVector<StringRef, 2> CommandLine; 211 CommandLine.push_back(Left); 212 CommandLine.push_back(Right); 213 if (EqualConcatenations(CommandLine, Buffers)) 214 return false; 215 216 SourceManager &SourceMgr = PP.getSourceManager(); 217 218 // The predefines buffers are different. Determine what the differences are, 219 // and whether they require us to reject the PCH file. 220 SmallVector<StringRef, 8> PCHLines; 221 for (unsigned I = 0, N = Buffers.size(); I != N; ++I) 222 Buffers[I].Data.split(PCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 223 224 SmallVector<StringRef, 8> CmdLineLines; 225 Left.split(CmdLineLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 226 227 // Pick out implicit #includes after the PCH and don't consider them for 228 // validation; we will insert them into SuggestedPredefines so that the 229 // preprocessor includes them. 230 std::string IncludesAfterPCH; 231 SmallVector<StringRef, 8> AfterPCHLines; 232 Right.split(AfterPCHLines, "\n", /*MaxSplit=*/-1, /*KeepEmpty=*/false); 233 for (unsigned i = 0, e = AfterPCHLines.size(); i != e; ++i) { 234 if (AfterPCHLines[i].startswith("#include ")) { 235 IncludesAfterPCH += AfterPCHLines[i]; 236 IncludesAfterPCH += '\n'; 237 } else { 238 CmdLineLines.push_back(AfterPCHLines[i]); 239 } 240 } 241 242 // Make sure we add the includes last into SuggestedPredefines before we 243 // exit this function. 244 struct AddIncludesRAII { 245 std::string &SuggestedPredefines; 246 std::string &IncludesAfterPCH; 247 248 AddIncludesRAII(std::string &SuggestedPredefines, 249 std::string &IncludesAfterPCH) 250 : SuggestedPredefines(SuggestedPredefines), 251 IncludesAfterPCH(IncludesAfterPCH) { } 252 ~AddIncludesRAII() { 253 SuggestedPredefines += IncludesAfterPCH; 254 } 255 } AddIncludes(SuggestedPredefines, IncludesAfterPCH); 256 257 // Sort both sets of predefined buffer lines, since we allow some extra 258 // definitions and they may appear at any point in the output. 259 std::sort(CmdLineLines.begin(), CmdLineLines.end()); 260 std::sort(PCHLines.begin(), PCHLines.end()); 261 262 // Determine which predefines that were used to build the PCH file are missing 263 // from the command line. 264 std::vector<StringRef> MissingPredefines; 265 std::set_difference(PCHLines.begin(), PCHLines.end(), 266 CmdLineLines.begin(), CmdLineLines.end(), 267 std::back_inserter(MissingPredefines)); 268 269 bool MissingDefines = false; 270 bool ConflictingDefines = false; 271 for (unsigned I = 0, N = MissingPredefines.size(); I != N; ++I) { 272 StringRef Missing = MissingPredefines[I]; 273 if (Missing.startswith("#include ")) { 274 // An -include was specified when generating the PCH; it is included in 275 // the PCH, just ignore it. 276 continue; 277 } 278 if (!Missing.startswith("#define ")) { 279 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 280 return true; 281 } 282 283 // This is a macro definition. Determine the name of the macro we're 284 // defining. 285 std::string::size_type StartOfMacroName = strlen("#define "); 286 std::string::size_type EndOfMacroName 287 = Missing.find_first_of("( \n\r", StartOfMacroName); 288 assert(EndOfMacroName != std::string::npos && 289 "Couldn't find the end of the macro name"); 290 StringRef MacroName = Missing.slice(StartOfMacroName, EndOfMacroName); 291 292 // Determine whether this macro was given a different definition on the 293 // command line. 294 std::string MacroDefStart = "#define " + MacroName.str(); 295 std::string::size_type MacroDefLen = MacroDefStart.size(); 296 SmallVector<StringRef, 8>::iterator ConflictPos 297 = std::lower_bound(CmdLineLines.begin(), CmdLineLines.end(), 298 MacroDefStart); 299 for (; ConflictPos != CmdLineLines.end(); ++ConflictPos) { 300 if (!ConflictPos->startswith(MacroDefStart)) { 301 // Different macro; we're done. 302 ConflictPos = CmdLineLines.end(); 303 break; 304 } 305 306 assert(ConflictPos->size() > MacroDefLen && 307 "Invalid #define in predefines buffer?"); 308 if ((*ConflictPos)[MacroDefLen] != ' ' && 309 (*ConflictPos)[MacroDefLen] != '(') 310 continue; // Longer macro name; keep trying. 311 312 // We found a conflicting macro definition. 313 break; 314 } 315 316 if (ConflictPos != CmdLineLines.end()) { 317 Reader.Diag(diag::warn_cmdline_conflicting_macro_def) 318 << MacroName; 319 320 // Show the definition of this macro within the PCH file. 321 std::pair<FileID, StringRef::size_type> MacroLoc = 322 FindMacro(Buffers, Missing); 323 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!"); 324 SourceLocation PCHMissingLoc = 325 SourceMgr.getLocForStartOfFile(MacroLoc.first) 326 .getLocWithOffset(MacroLoc.second); 327 Reader.Diag(PCHMissingLoc, diag::note_pch_macro_defined_as) << MacroName; 328 329 ConflictingDefines = true; 330 continue; 331 } 332 333 // If the macro doesn't conflict, then we'll just pick up the macro 334 // definition from the PCH file. Warn the user that they made a mistake. 335 if (ConflictingDefines) 336 continue; // Don't complain if there are already conflicting defs 337 338 if (!MissingDefines) { 339 Reader.Diag(diag::warn_cmdline_missing_macro_defs); 340 MissingDefines = true; 341 } 342 343 // Show the definition of this macro within the PCH file. 344 std::pair<FileID, StringRef::size_type> MacroLoc = 345 FindMacro(Buffers, Missing); 346 assert(MacroLoc.second!=StringRef::npos && "Unable to find macro!"); 347 SourceLocation PCHMissingLoc = 348 SourceMgr.getLocForStartOfFile(MacroLoc.first) 349 .getLocWithOffset(MacroLoc.second); 350 Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch); 351 } 352 353 if (ConflictingDefines) 354 return true; 355 356 // Determine what predefines were introduced based on command-line 357 // parameters that were not present when building the PCH 358 // file. Extra #defines are okay, so long as the identifiers being 359 // defined were not used within the precompiled header. 360 std::vector<StringRef> ExtraPredefines; 361 std::set_difference(CmdLineLines.begin(), CmdLineLines.end(), 362 PCHLines.begin(), PCHLines.end(), 363 std::back_inserter(ExtraPredefines)); 364 for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) { 365 StringRef &Extra = ExtraPredefines[I]; 366 if (!Extra.startswith("#define ")) { 367 Reader.Diag(diag::warn_pch_compiler_options_mismatch); 368 return true; 369 } 370 371 // This is an extra macro definition. Determine the name of the 372 // macro we're defining. 373 std::string::size_type StartOfMacroName = strlen("#define "); 374 std::string::size_type EndOfMacroName 375 = Extra.find_first_of("( \n\r", StartOfMacroName); 376 assert(EndOfMacroName != std::string::npos && 377 "Couldn't find the end of the macro name"); 378 StringRef MacroName = Extra.slice(StartOfMacroName, EndOfMacroName); 379 380 // Check whether this name was used somewhere in the PCH file. If 381 // so, defining it as a macro could change behavior, so we reject 382 // the PCH file. 383 if (IdentifierInfo *II = Reader.get(MacroName)) { 384 Reader.Diag(diag::warn_macro_name_used_in_pch) << II; 385 return true; 386 } 387 388 // Add this definition to the suggested predefines buffer. 389 SuggestedPredefines += Extra; 390 SuggestedPredefines += '\n'; 391 } 392 393 // If we get here, it's because the predefines buffer had compatible 394 // contents. Accept the PCH file. 395 return false; 396} 397 398void PCHValidator::ReadHeaderFileInfo(const HeaderFileInfo &HFI, 399 unsigned ID) { 400 PP.getHeaderSearchInfo().setHeaderFileInfoForUID(HFI, ID); 401 ++NumHeaderInfos; 402} 403 404void PCHValidator::ReadCounter(unsigned Value) { 405 PP.setCounterValue(Value); 406} 407 408//===----------------------------------------------------------------------===// 409// AST reader implementation 410//===----------------------------------------------------------------------===// 411 412void 413ASTReader::setDeserializationListener(ASTDeserializationListener *Listener) { 414 DeserializationListener = Listener; 415} 416 417 418 419unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) { 420 return serialization::ComputeHash(Sel); 421} 422 423 424std::pair<unsigned, unsigned> 425ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 426 using namespace clang::io; 427 unsigned KeyLen = ReadUnalignedLE16(d); 428 unsigned DataLen = ReadUnalignedLE16(d); 429 return std::make_pair(KeyLen, DataLen); 430} 431 432ASTSelectorLookupTrait::internal_key_type 433ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) { 434 using namespace clang::io; 435 SelectorTable &SelTable = Reader.getContext().Selectors; 436 unsigned N = ReadUnalignedLE16(d); 437 IdentifierInfo *FirstII 438 = Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 439 if (N == 0) 440 return SelTable.getNullarySelector(FirstII); 441 else if (N == 1) 442 return SelTable.getUnarySelector(FirstII); 443 444 SmallVector<IdentifierInfo *, 16> Args; 445 Args.push_back(FirstII); 446 for (unsigned I = 1; I != N; ++I) 447 Args.push_back(Reader.getLocalIdentifier(F, ReadUnalignedLE32(d))); 448 449 return SelTable.getSelector(N, Args.data()); 450} 451 452ASTSelectorLookupTrait::data_type 453ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d, 454 unsigned DataLen) { 455 using namespace clang::io; 456 457 data_type Result; 458 459 Result.ID = Reader.getGlobalSelectorID(F, ReadUnalignedLE32(d)); 460 unsigned NumInstanceMethods = ReadUnalignedLE16(d); 461 unsigned NumFactoryMethods = ReadUnalignedLE16(d); 462 463 // Load instance methods 464 for (unsigned I = 0; I != NumInstanceMethods; ++I) { 465 if (ObjCMethodDecl *Method 466 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d))) 467 Result.Instance.push_back(Method); 468 } 469 470 // Load factory methods 471 for (unsigned I = 0; I != NumFactoryMethods; ++I) { 472 if (ObjCMethodDecl *Method 473 = Reader.GetLocalDeclAs<ObjCMethodDecl>(F, ReadUnalignedLE32(d))) 474 Result.Factory.push_back(Method); 475 } 476 477 return Result; 478} 479 480unsigned ASTIdentifierLookupTrait::ComputeHash(const internal_key_type& a) { 481 return llvm::HashString(StringRef(a.first, a.second)); 482} 483 484std::pair<unsigned, unsigned> 485ASTIdentifierLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 486 using namespace clang::io; 487 unsigned DataLen = ReadUnalignedLE16(d); 488 unsigned KeyLen = ReadUnalignedLE16(d); 489 return std::make_pair(KeyLen, DataLen); 490} 491 492std::pair<const char*, unsigned> 493ASTIdentifierLookupTrait::ReadKey(const unsigned char* d, unsigned n) { 494 assert(n >= 2 && d[n-1] == '\0'); 495 return std::make_pair((const char*) d, n-1); 496} 497 498IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k, 499 const unsigned char* d, 500 unsigned DataLen) { 501 using namespace clang::io; 502 unsigned RawID = ReadUnalignedLE32(d); 503 bool IsInteresting = RawID & 0x01; 504 505 // Wipe out the "is interesting" bit. 506 RawID = RawID >> 1; 507 508 IdentID ID = Reader.getGlobalIdentifierID(F, RawID); 509 if (!IsInteresting) { 510 // For uninteresting identifiers, just build the IdentifierInfo 511 // and associate it with the persistent ID. 512 IdentifierInfo *II = KnownII; 513 if (!II) 514 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second)); 515 Reader.SetIdentifierInfo(ID, II); 516 II->setIsFromAST(); 517 return II; 518 } 519 520 unsigned Bits = ReadUnalignedLE16(d); 521 bool CPlusPlusOperatorKeyword = Bits & 0x01; 522 Bits >>= 1; 523 bool HasRevertedTokenIDToIdentifier = Bits & 0x01; 524 Bits >>= 1; 525 bool Poisoned = Bits & 0x01; 526 Bits >>= 1; 527 bool ExtensionToken = Bits & 0x01; 528 Bits >>= 1; 529 bool hasMacroDefinition = Bits & 0x01; 530 Bits >>= 1; 531 unsigned ObjCOrBuiltinID = Bits & 0x3FF; 532 Bits >>= 10; 533 534 assert(Bits == 0 && "Extra bits in the identifier?"); 535 DataLen -= 6; 536 537 // Build the IdentifierInfo itself and link the identifier ID with 538 // the new IdentifierInfo. 539 IdentifierInfo *II = KnownII; 540 if (!II) 541 II = &Reader.getIdentifierTable().getOwn(StringRef(k.first, k.second)); 542 Reader.SetIdentifierInfo(ID, II); 543 544 // Set or check the various bits in the IdentifierInfo structure. 545 // Token IDs are read-only. 546 if (HasRevertedTokenIDToIdentifier) 547 II->RevertTokenIDToIdentifier(); 548 II->setObjCOrBuiltinID(ObjCOrBuiltinID); 549 assert(II->isExtensionToken() == ExtensionToken && 550 "Incorrect extension token flag"); 551 (void)ExtensionToken; 552 if (Poisoned) 553 II->setIsPoisoned(true); 554 assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword && 555 "Incorrect C++ operator keyword flag"); 556 (void)CPlusPlusOperatorKeyword; 557 558 // If this identifier is a macro, deserialize the macro 559 // definition. 560 if (hasMacroDefinition) { 561 // FIXME: Check for conflicts? 562 uint32_t Offset = ReadUnalignedLE32(d); 563 Reader.SetIdentifierIsMacro(II, F, Offset); 564 DataLen -= 4; 565 } 566 567 // Read all of the declarations visible at global scope with this 568 // name. 569 if (DataLen > 0) { 570 SmallVector<uint32_t, 4> DeclIDs; 571 for (; DataLen > 0; DataLen -= 4) 572 DeclIDs.push_back(Reader.getGlobalDeclID(F, ReadUnalignedLE32(d))); 573 Reader.SetGloballyVisibleDecls(II, DeclIDs); 574 } 575 576 II->setIsFromAST(); 577 return II; 578} 579 580unsigned 581ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const { 582 llvm::FoldingSetNodeID ID; 583 ID.AddInteger(Key.Kind); 584 585 switch (Key.Kind) { 586 case DeclarationName::Identifier: 587 case DeclarationName::CXXLiteralOperatorName: 588 ID.AddString(((IdentifierInfo*)Key.Data)->getName()); 589 break; 590 case DeclarationName::ObjCZeroArgSelector: 591 case DeclarationName::ObjCOneArgSelector: 592 case DeclarationName::ObjCMultiArgSelector: 593 ID.AddInteger(serialization::ComputeHash(Selector(Key.Data))); 594 break; 595 case DeclarationName::CXXOperatorName: 596 ID.AddInteger((OverloadedOperatorKind)Key.Data); 597 break; 598 case DeclarationName::CXXConstructorName: 599 case DeclarationName::CXXDestructorName: 600 case DeclarationName::CXXConversionFunctionName: 601 case DeclarationName::CXXUsingDirective: 602 break; 603 } 604 605 return ID.ComputeHash(); 606} 607 608ASTDeclContextNameLookupTrait::internal_key_type 609ASTDeclContextNameLookupTrait::GetInternalKey( 610 const external_key_type& Name) const { 611 DeclNameKey Key; 612 Key.Kind = Name.getNameKind(); 613 switch (Name.getNameKind()) { 614 case DeclarationName::Identifier: 615 Key.Data = (uint64_t)Name.getAsIdentifierInfo(); 616 break; 617 case DeclarationName::ObjCZeroArgSelector: 618 case DeclarationName::ObjCOneArgSelector: 619 case DeclarationName::ObjCMultiArgSelector: 620 Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr(); 621 break; 622 case DeclarationName::CXXOperatorName: 623 Key.Data = Name.getCXXOverloadedOperator(); 624 break; 625 case DeclarationName::CXXLiteralOperatorName: 626 Key.Data = (uint64_t)Name.getCXXLiteralIdentifier(); 627 break; 628 case DeclarationName::CXXConstructorName: 629 case DeclarationName::CXXDestructorName: 630 case DeclarationName::CXXConversionFunctionName: 631 case DeclarationName::CXXUsingDirective: 632 Key.Data = 0; 633 break; 634 } 635 636 return Key; 637} 638 639ASTDeclContextNameLookupTrait::external_key_type 640ASTDeclContextNameLookupTrait::GetExternalKey( 641 const internal_key_type& Key) const { 642 ASTContext &Context = Reader.getContext(); 643 switch (Key.Kind) { 644 case DeclarationName::Identifier: 645 return DeclarationName((IdentifierInfo*)Key.Data); 646 647 case DeclarationName::ObjCZeroArgSelector: 648 case DeclarationName::ObjCOneArgSelector: 649 case DeclarationName::ObjCMultiArgSelector: 650 return DeclarationName(Selector(Key.Data)); 651 652 case DeclarationName::CXXConstructorName: 653 return Context.DeclarationNames.getCXXConstructorName( 654 Context.getCanonicalType(Reader.getLocalType(F, Key.Data))); 655 656 case DeclarationName::CXXDestructorName: 657 return Context.DeclarationNames.getCXXDestructorName( 658 Context.getCanonicalType(Reader.getLocalType(F, Key.Data))); 659 660 case DeclarationName::CXXConversionFunctionName: 661 return Context.DeclarationNames.getCXXConversionFunctionName( 662 Context.getCanonicalType(Reader.getLocalType(F, Key.Data))); 663 664 case DeclarationName::CXXOperatorName: 665 return Context.DeclarationNames.getCXXOperatorName( 666 (OverloadedOperatorKind)Key.Data); 667 668 case DeclarationName::CXXLiteralOperatorName: 669 return Context.DeclarationNames.getCXXLiteralOperatorName( 670 (IdentifierInfo*)Key.Data); 671 672 case DeclarationName::CXXUsingDirective: 673 return DeclarationName::getUsingDirectiveName(); 674 } 675 676 llvm_unreachable("Invalid Name Kind ?"); 677} 678 679std::pair<unsigned, unsigned> 680ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char*& d) { 681 using namespace clang::io; 682 unsigned KeyLen = ReadUnalignedLE16(d); 683 unsigned DataLen = ReadUnalignedLE16(d); 684 return std::make_pair(KeyLen, DataLen); 685} 686 687ASTDeclContextNameLookupTrait::internal_key_type 688ASTDeclContextNameLookupTrait::ReadKey(const unsigned char* d, unsigned) { 689 using namespace clang::io; 690 691 DeclNameKey Key; 692 Key.Kind = (DeclarationName::NameKind)*d++; 693 switch (Key.Kind) { 694 case DeclarationName::Identifier: 695 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 696 break; 697 case DeclarationName::ObjCZeroArgSelector: 698 case DeclarationName::ObjCOneArgSelector: 699 case DeclarationName::ObjCMultiArgSelector: 700 Key.Data = 701 (uint64_t)Reader.getLocalSelector(F, ReadUnalignedLE32(d)) 702 .getAsOpaquePtr(); 703 break; 704 case DeclarationName::CXXOperatorName: 705 Key.Data = *d++; // OverloadedOperatorKind 706 break; 707 case DeclarationName::CXXLiteralOperatorName: 708 Key.Data = (uint64_t)Reader.getLocalIdentifier(F, ReadUnalignedLE32(d)); 709 break; 710 case DeclarationName::CXXConstructorName: 711 case DeclarationName::CXXDestructorName: 712 case DeclarationName::CXXConversionFunctionName: 713 case DeclarationName::CXXUsingDirective: 714 Key.Data = 0; 715 break; 716 } 717 718 return Key; 719} 720 721ASTDeclContextNameLookupTrait::data_type 722ASTDeclContextNameLookupTrait::ReadData(internal_key_type, 723 const unsigned char* d, 724 unsigned DataLen) { 725 using namespace clang::io; 726 unsigned NumDecls = ReadUnalignedLE16(d); 727 DeclID *Start = (DeclID *)d; 728 return std::make_pair(Start, Start + NumDecls); 729} 730 731bool ASTReader::ReadDeclContextStorage(Module &M, 732 llvm::BitstreamCursor &Cursor, 733 const std::pair<uint64_t, uint64_t> &Offsets, 734 DeclContextInfo &Info) { 735 SavedStreamPosition SavedPosition(Cursor); 736 // First the lexical decls. 737 if (Offsets.first != 0) { 738 Cursor.JumpToBit(Offsets.first); 739 740 RecordData Record; 741 const char *Blob; 742 unsigned BlobLen; 743 unsigned Code = Cursor.ReadCode(); 744 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 745 if (RecCode != DECL_CONTEXT_LEXICAL) { 746 Error("Expected lexical block"); 747 return true; 748 } 749 750 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob); 751 Info.NumLexicalDecls = BlobLen / sizeof(KindDeclIDPair); 752 } 753 754 // Now the lookup table. 755 if (Offsets.second != 0) { 756 Cursor.JumpToBit(Offsets.second); 757 758 RecordData Record; 759 const char *Blob; 760 unsigned BlobLen; 761 unsigned Code = Cursor.ReadCode(); 762 unsigned RecCode = Cursor.ReadRecord(Code, Record, &Blob, &BlobLen); 763 if (RecCode != DECL_CONTEXT_VISIBLE) { 764 Error("Expected visible lookup table block"); 765 return true; 766 } 767 Info.NameLookupTableData 768 = ASTDeclContextNameLookupTable::Create( 769 (const unsigned char *)Blob + Record[0], 770 (const unsigned char *)Blob, 771 ASTDeclContextNameLookupTrait(*this, M)); 772 } 773 774 return false; 775} 776 777void ASTReader::Error(StringRef Msg) { 778 Error(diag::err_fe_pch_malformed, Msg); 779} 780 781void ASTReader::Error(unsigned DiagID, 782 StringRef Arg1, StringRef Arg2) { 783 if (Diags.isDiagnosticInFlight()) 784 Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2); 785 else 786 Diag(DiagID) << Arg1 << Arg2; 787} 788 789/// \brief Tell the AST listener about the predefines buffers in the chain. 790bool ASTReader::CheckPredefinesBuffers() { 791 if (Listener) 792 return Listener->ReadPredefinesBuffer(PCHPredefinesBuffers, 793 ActualOriginalFileName, 794 SuggestedPredefines, 795 FileMgr); 796 return false; 797} 798 799//===----------------------------------------------------------------------===// 800// Source Manager Deserialization 801//===----------------------------------------------------------------------===// 802 803/// \brief Read the line table in the source manager block. 804/// \returns true if there was an error. 805bool ASTReader::ParseLineTable(Module &F, 806 SmallVectorImpl<uint64_t> &Record) { 807 unsigned Idx = 0; 808 LineTableInfo &LineTable = SourceMgr.getLineTable(); 809 810 // Parse the file names 811 std::map<int, int> FileIDs; 812 for (int I = 0, N = Record[Idx++]; I != N; ++I) { 813 // Extract the file name 814 unsigned FilenameLen = Record[Idx++]; 815 std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); 816 Idx += FilenameLen; 817 MaybeAddSystemRootToFilename(Filename); 818 FileIDs[I] = LineTable.getLineTableFilenameID(Filename); 819 } 820 821 // Parse the line entries 822 std::vector<LineEntry> Entries; 823 while (Idx < Record.size()) { 824 int FID = Record[Idx++]; 825 assert(FID >= 0 && "Serialized line entries for non-local file."); 826 // Remap FileID from 1-based old view. 827 FID += F.SLocEntryBaseID - 1; 828 829 // Extract the line entries 830 unsigned NumEntries = Record[Idx++]; 831 assert(NumEntries && "Numentries is 00000"); 832 Entries.clear(); 833 Entries.reserve(NumEntries); 834 for (unsigned I = 0; I != NumEntries; ++I) { 835 unsigned FileOffset = Record[Idx++]; 836 unsigned LineNo = Record[Idx++]; 837 int FilenameID = FileIDs[Record[Idx++]]; 838 SrcMgr::CharacteristicKind FileKind 839 = (SrcMgr::CharacteristicKind)Record[Idx++]; 840 unsigned IncludeOffset = Record[Idx++]; 841 Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, 842 FileKind, IncludeOffset)); 843 } 844 LineTable.AddEntry(FID, Entries); 845 } 846 847 return false; 848} 849 850namespace { 851 852class ASTStatData { 853public: 854 const ino_t ino; 855 const dev_t dev; 856 const mode_t mode; 857 const time_t mtime; 858 const off_t size; 859 860 ASTStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s) 861 : ino(i), dev(d), mode(mo), mtime(m), size(s) {} 862}; 863 864class ASTStatLookupTrait { 865 public: 866 typedef const char *external_key_type; 867 typedef const char *internal_key_type; 868 869 typedef ASTStatData data_type; 870 871 static unsigned ComputeHash(const char *path) { 872 return llvm::HashString(path); 873 } 874 875 static internal_key_type GetInternalKey(const char *path) { return path; } 876 877 static bool EqualKey(internal_key_type a, internal_key_type b) { 878 return strcmp(a, b) == 0; 879 } 880 881 static std::pair<unsigned, unsigned> 882 ReadKeyDataLength(const unsigned char*& d) { 883 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 884 unsigned DataLen = (unsigned) *d++; 885 return std::make_pair(KeyLen + 1, DataLen); 886 } 887 888 static internal_key_type ReadKey(const unsigned char *d, unsigned) { 889 return (const char *)d; 890 } 891 892 static data_type ReadData(const internal_key_type, const unsigned char *d, 893 unsigned /*DataLen*/) { 894 using namespace clang::io; 895 896 ino_t ino = (ino_t) ReadUnalignedLE32(d); 897 dev_t dev = (dev_t) ReadUnalignedLE32(d); 898 mode_t mode = (mode_t) ReadUnalignedLE16(d); 899 time_t mtime = (time_t) ReadUnalignedLE64(d); 900 off_t size = (off_t) ReadUnalignedLE64(d); 901 return data_type(ino, dev, mode, mtime, size); 902 } 903}; 904 905/// \brief stat() cache for precompiled headers. 906/// 907/// This cache is very similar to the stat cache used by pretokenized 908/// headers. 909class ASTStatCache : public FileSystemStatCache { 910 typedef OnDiskChainedHashTable<ASTStatLookupTrait> CacheTy; 911 CacheTy *Cache; 912 913 unsigned &NumStatHits, &NumStatMisses; 914public: 915 ASTStatCache(const unsigned char *Buckets, const unsigned char *Base, 916 unsigned &NumStatHits, unsigned &NumStatMisses) 917 : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) { 918 Cache = CacheTy::Create(Buckets, Base); 919 } 920 921 ~ASTStatCache() { delete Cache; } 922 923 LookupResult getStat(const char *Path, struct stat &StatBuf, 924 int *FileDescriptor) { 925 // Do the lookup for the file's data in the AST file. 926 CacheTy::iterator I = Cache->find(Path); 927 928 // If we don't get a hit in the AST file just forward to 'stat'. 929 if (I == Cache->end()) { 930 ++NumStatMisses; 931 return statChained(Path, StatBuf, FileDescriptor); 932 } 933 934 ++NumStatHits; 935 ASTStatData Data = *I; 936 937 StatBuf.st_ino = Data.ino; 938 StatBuf.st_dev = Data.dev; 939 StatBuf.st_mtime = Data.mtime; 940 StatBuf.st_mode = Data.mode; 941 StatBuf.st_size = Data.size; 942 return CacheExists; 943 } 944}; 945} // end anonymous namespace 946 947 948/// \brief Read a source manager block 949ASTReader::ASTReadResult ASTReader::ReadSourceManagerBlock(Module &F) { 950 using namespace SrcMgr; 951 952 llvm::BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor; 953 954 // Set the source-location entry cursor to the current position in 955 // the stream. This cursor will be used to read the contents of the 956 // source manager block initially, and then lazily read 957 // source-location entries as needed. 958 SLocEntryCursor = F.Stream; 959 960 // The stream itself is going to skip over the source manager block. 961 if (F.Stream.SkipBlock()) { 962 Error("malformed block record in AST file"); 963 return Failure; 964 } 965 966 // Enter the source manager block. 967 if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) { 968 Error("malformed source manager block record in AST file"); 969 return Failure; 970 } 971 972 RecordData Record; 973 while (true) { 974 unsigned Code = SLocEntryCursor.ReadCode(); 975 if (Code == llvm::bitc::END_BLOCK) { 976 if (SLocEntryCursor.ReadBlockEnd()) { 977 Error("error at end of Source Manager block in AST file"); 978 return Failure; 979 } 980 return Success; 981 } 982 983 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 984 // No known subblocks, always skip them. 985 SLocEntryCursor.ReadSubBlockID(); 986 if (SLocEntryCursor.SkipBlock()) { 987 Error("malformed block record in AST file"); 988 return Failure; 989 } 990 continue; 991 } 992 993 if (Code == llvm::bitc::DEFINE_ABBREV) { 994 SLocEntryCursor.ReadAbbrevRecord(); 995 continue; 996 } 997 998 // Read a record. 999 const char *BlobStart; 1000 unsigned BlobLen; 1001 Record.clear(); 1002 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1003 default: // Default behavior: ignore. 1004 break; 1005 1006 case SM_SLOC_FILE_ENTRY: 1007 case SM_SLOC_BUFFER_ENTRY: 1008 case SM_SLOC_EXPANSION_ENTRY: 1009 // Once we hit one of the source location entries, we're done. 1010 return Success; 1011 } 1012 } 1013} 1014 1015/// \brief If a header file is not found at the path that we expect it to be 1016/// and the PCH file was moved from its original location, try to resolve the 1017/// file by assuming that header+PCH were moved together and the header is in 1018/// the same place relative to the PCH. 1019static std::string 1020resolveFileRelativeToOriginalDir(const std::string &Filename, 1021 const std::string &OriginalDir, 1022 const std::string &CurrDir) { 1023 assert(OriginalDir != CurrDir && 1024 "No point trying to resolve the file if the PCH dir didn't change"); 1025 using namespace llvm::sys; 1026 llvm::SmallString<128> filePath(Filename); 1027 fs::make_absolute(filePath); 1028 assert(path::is_absolute(OriginalDir)); 1029 llvm::SmallString<128> currPCHPath(CurrDir); 1030 1031 path::const_iterator fileDirI = path::begin(path::parent_path(filePath)), 1032 fileDirE = path::end(path::parent_path(filePath)); 1033 path::const_iterator origDirI = path::begin(OriginalDir), 1034 origDirE = path::end(OriginalDir); 1035 // Skip the common path components from filePath and OriginalDir. 1036 while (fileDirI != fileDirE && origDirI != origDirE && 1037 *fileDirI == *origDirI) { 1038 ++fileDirI; 1039 ++origDirI; 1040 } 1041 for (; origDirI != origDirE; ++origDirI) 1042 path::append(currPCHPath, ".."); 1043 path::append(currPCHPath, fileDirI, fileDirE); 1044 path::append(currPCHPath, path::filename(Filename)); 1045 return currPCHPath.str(); 1046} 1047 1048/// \brief Read in the source location entry with the given ID. 1049ASTReader::ASTReadResult ASTReader::ReadSLocEntryRecord(int ID) { 1050 if (ID == 0) 1051 return Success; 1052 1053 if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) { 1054 Error("source location entry ID out-of-range for AST file"); 1055 return Failure; 1056 } 1057 1058 Module *F = GlobalSLocEntryMap.find(-ID)->second; 1059 F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]); 1060 llvm::BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor; 1061 unsigned BaseOffset = F->SLocEntryBaseOffset; 1062 1063 ++NumSLocEntriesRead; 1064 unsigned Code = SLocEntryCursor.ReadCode(); 1065 if (Code == llvm::bitc::END_BLOCK || 1066 Code == llvm::bitc::ENTER_SUBBLOCK || 1067 Code == llvm::bitc::DEFINE_ABBREV) { 1068 Error("incorrectly-formatted source location entry in AST file"); 1069 return Failure; 1070 } 1071 1072 RecordData Record; 1073 const char *BlobStart; 1074 unsigned BlobLen; 1075 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1076 default: 1077 Error("incorrectly-formatted source location entry in AST file"); 1078 return Failure; 1079 1080 case SM_SLOC_FILE_ENTRY: { 1081 std::string Filename(BlobStart, BlobStart + BlobLen); 1082 MaybeAddSystemRootToFilename(Filename); 1083 const FileEntry *File = FileMgr.getFile(Filename); 1084 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1085 OriginalDir != CurrentDir) { 1086 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1087 OriginalDir, 1088 CurrentDir); 1089 if (!resolved.empty()) 1090 File = FileMgr.getFile(resolved); 1091 } 1092 if (File == 0) 1093 File = FileMgr.getVirtualFile(Filename, (off_t)Record[4], 1094 (time_t)Record[5]); 1095 if (File == 0) { 1096 std::string ErrorStr = "could not find file '"; 1097 ErrorStr += Filename; 1098 ErrorStr += "' referenced by AST file"; 1099 Error(ErrorStr.c_str()); 1100 return Failure; 1101 } 1102 1103 if (Record.size() < 6) { 1104 Error("source location entry is incorrect"); 1105 return Failure; 1106 } 1107 1108 if (!DisableValidation && 1109 ((off_t)Record[4] != File->getSize() 1110#if !defined(LLVM_ON_WIN32) 1111 // In our regression testing, the Windows file system seems to 1112 // have inconsistent modification times that sometimes 1113 // erroneously trigger this error-handling path. 1114 || (time_t)Record[5] != File->getModificationTime() 1115#endif 1116 )) { 1117 Error(diag::err_fe_pch_file_modified, Filename); 1118 return Failure; 1119 } 1120 1121 SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]); 1122 if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) { 1123 // This is the module's main file. 1124 IncludeLoc = getImportLocation(F); 1125 } 1126 FileID FID = SourceMgr.createFileID(File, IncludeLoc, 1127 (SrcMgr::CharacteristicKind)Record[2], 1128 ID, BaseOffset + Record[0]); 1129 SrcMgr::FileInfo &FileInfo = 1130 const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile()); 1131 FileInfo.NumCreatedFIDs = Record[6]; 1132 if (Record[3]) 1133 FileInfo.setHasLineDirectives(); 1134 1135 break; 1136 } 1137 1138 case SM_SLOC_BUFFER_ENTRY: { 1139 const char *Name = BlobStart; 1140 unsigned Offset = Record[0]; 1141 unsigned Code = SLocEntryCursor.ReadCode(); 1142 Record.clear(); 1143 unsigned RecCode 1144 = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen); 1145 1146 if (RecCode != SM_SLOC_BUFFER_BLOB) { 1147 Error("AST record has invalid code"); 1148 return Failure; 1149 } 1150 1151 llvm::MemoryBuffer *Buffer 1152 = llvm::MemoryBuffer::getMemBuffer(StringRef(BlobStart, BlobLen - 1), 1153 Name); 1154 FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, 1155 BaseOffset + Offset); 1156 1157 if (strcmp(Name, "<built-in>") == 0) { 1158 PCHPredefinesBlock Block = { 1159 BufferID, 1160 StringRef(BlobStart, BlobLen - 1) 1161 }; 1162 PCHPredefinesBuffers.push_back(Block); 1163 } 1164 1165 break; 1166 } 1167 1168 case SM_SLOC_EXPANSION_ENTRY: { 1169 SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]); 1170 SourceMgr.createExpansionLoc(SpellingLoc, 1171 ReadSourceLocation(*F, Record[2]), 1172 ReadSourceLocation(*F, Record[3]), 1173 Record[4], 1174 ID, 1175 BaseOffset + Record[0]); 1176 break; 1177 } 1178 } 1179 1180 return Success; 1181} 1182 1183/// \brief Find the location where the module F is imported. 1184SourceLocation ASTReader::getImportLocation(Module *F) { 1185 if (F->ImportLoc.isValid()) 1186 return F->ImportLoc; 1187 1188 // Otherwise we have a PCH. It's considered to be "imported" at the first 1189 // location of its includer. 1190 if (F->ImportedBy.empty() || !F->ImportedBy[0]) { 1191 // Main file is the importer. We assume that it is the first entry in the 1192 // entry table. We can't ask the manager, because at the time of PCH loading 1193 // the main file entry doesn't exist yet. 1194 // The very first entry is the invalid instantiation loc, which takes up 1195 // offsets 0 and 1. 1196 return SourceLocation::getFromRawEncoding(2U); 1197 } 1198 //return F->Loaders[0]->FirstLoc; 1199 return F->ImportedBy[0]->FirstLoc; 1200} 1201 1202/// ReadBlockAbbrevs - Enter a subblock of the specified BlockID with the 1203/// specified cursor. Read the abbreviations that are at the top of the block 1204/// and then leave the cursor pointing into the block. 1205bool ASTReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, 1206 unsigned BlockID) { 1207 if (Cursor.EnterSubBlock(BlockID)) { 1208 Error("malformed block record in AST file"); 1209 return Failure; 1210 } 1211 1212 while (true) { 1213 uint64_t Offset = Cursor.GetCurrentBitNo(); 1214 unsigned Code = Cursor.ReadCode(); 1215 1216 // We expect all abbrevs to be at the start of the block. 1217 if (Code != llvm::bitc::DEFINE_ABBREV) { 1218 Cursor.JumpToBit(Offset); 1219 return false; 1220 } 1221 Cursor.ReadAbbrevRecord(); 1222 } 1223} 1224 1225void ASTReader::ReadMacroRecord(Module &F, uint64_t Offset) { 1226 llvm::BitstreamCursor &Stream = F.MacroCursor; 1227 1228 // Keep track of where we are in the stream, then jump back there 1229 // after reading this macro. 1230 SavedStreamPosition SavedPosition(Stream); 1231 1232 Stream.JumpToBit(Offset); 1233 RecordData Record; 1234 SmallVector<IdentifierInfo*, 16> MacroArgs; 1235 MacroInfo *Macro = 0; 1236 1237 while (true) { 1238 unsigned Code = Stream.ReadCode(); 1239 switch (Code) { 1240 case llvm::bitc::END_BLOCK: 1241 return; 1242 1243 case llvm::bitc::ENTER_SUBBLOCK: 1244 // No known subblocks, always skip them. 1245 Stream.ReadSubBlockID(); 1246 if (Stream.SkipBlock()) { 1247 Error("malformed block record in AST file"); 1248 return; 1249 } 1250 continue; 1251 1252 case llvm::bitc::DEFINE_ABBREV: 1253 Stream.ReadAbbrevRecord(); 1254 continue; 1255 default: break; 1256 } 1257 1258 // Read a record. 1259 const char *BlobStart = 0; 1260 unsigned BlobLen = 0; 1261 Record.clear(); 1262 PreprocessorRecordTypes RecType = 1263 (PreprocessorRecordTypes)Stream.ReadRecord(Code, Record, BlobStart, 1264 BlobLen); 1265 switch (RecType) { 1266 case PP_MACRO_OBJECT_LIKE: 1267 case PP_MACRO_FUNCTION_LIKE: { 1268 // If we already have a macro, that means that we've hit the end 1269 // of the definition of the macro we were looking for. We're 1270 // done. 1271 if (Macro) 1272 return; 1273 1274 IdentifierInfo *II = getLocalIdentifier(F, Record[0]); 1275 if (II == 0) { 1276 Error("macro must have a name in AST file"); 1277 return; 1278 } 1279 SourceLocation Loc = ReadSourceLocation(F, Record[1]); 1280 bool isUsed = Record[2]; 1281 1282 MacroInfo *MI = PP.AllocateMacroInfo(Loc); 1283 MI->setIsUsed(isUsed); 1284 MI->setIsFromAST(); 1285 1286 unsigned NextIndex = 3; 1287 MI->setExportLocation(ReadSourceLocation(F, Record, NextIndex)); 1288 1289 if (RecType == PP_MACRO_FUNCTION_LIKE) { 1290 // Decode function-like macro info. 1291 bool isC99VarArgs = Record[NextIndex++]; 1292 bool isGNUVarArgs = Record[NextIndex++]; 1293 MacroArgs.clear(); 1294 unsigned NumArgs = Record[NextIndex++]; 1295 for (unsigned i = 0; i != NumArgs; ++i) 1296 MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++])); 1297 1298 // Install function-like macro info. 1299 MI->setIsFunctionLike(); 1300 if (isC99VarArgs) MI->setIsC99Varargs(); 1301 if (isGNUVarArgs) MI->setIsGNUVarargs(); 1302 MI->setArgumentList(MacroArgs.data(), MacroArgs.size(), 1303 PP.getPreprocessorAllocator()); 1304 } 1305 1306 // Finally, install the macro. 1307 PP.setMacroInfo(II, MI); 1308 1309 // Remember that we saw this macro last so that we add the tokens that 1310 // form its body to it. 1311 Macro = MI; 1312 1313 if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() && 1314 Record[NextIndex]) { 1315 // We have a macro definition. Register the association 1316 PreprocessedEntityID 1317 GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]); 1318 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 1319 PPRec.RegisterMacroDefinition(Macro, 1320 PPRec.getPPEntityID(GlobalID-1, /*isLoaded=*/true)); 1321 } 1322 1323 ++NumMacrosRead; 1324 break; 1325 } 1326 1327 case PP_TOKEN: { 1328 // If we see a TOKEN before a PP_MACRO_*, then the file is 1329 // erroneous, just pretend we didn't see this. 1330 if (Macro == 0) break; 1331 1332 Token Tok; 1333 Tok.startToken(); 1334 Tok.setLocation(ReadSourceLocation(F, Record[0])); 1335 Tok.setLength(Record[1]); 1336 if (IdentifierInfo *II = getLocalIdentifier(F, Record[2])) 1337 Tok.setIdentifierInfo(II); 1338 Tok.setKind((tok::TokenKind)Record[3]); 1339 Tok.setFlag((Token::TokenFlags)Record[4]); 1340 Macro->AddTokenToBody(Tok); 1341 break; 1342 } 1343 } 1344 } 1345 1346 return; 1347} 1348 1349PreprocessedEntityID 1350ASTReader::getGlobalPreprocessedEntityID(Module &M, unsigned LocalID) const { 1351 ContinuousRangeMap<uint32_t, int, 2>::const_iterator 1352 I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS); 1353 assert(I != M.PreprocessedEntityRemap.end() 1354 && "Invalid index into preprocessed entity index remap"); 1355 1356 return LocalID + I->second; 1357} 1358 1359unsigned HeaderFileInfoTrait::ComputeHash(const char *path) { 1360 return llvm::HashString(llvm::sys::path::filename(path)); 1361} 1362 1363HeaderFileInfoTrait::internal_key_type 1364HeaderFileInfoTrait::GetInternalKey(const char *path) { return path; } 1365 1366bool HeaderFileInfoTrait::EqualKey(internal_key_type a, internal_key_type b) { 1367 if (strcmp(a, b) == 0) 1368 return true; 1369 1370 if (llvm::sys::path::filename(a) != llvm::sys::path::filename(b)) 1371 return false; 1372 1373 // The file names match, but the path names don't. stat() the files to 1374 // see if they are the same. 1375 struct stat StatBufA, StatBufB; 1376 if (StatSimpleCache(a, &StatBufA) || StatSimpleCache(b, &StatBufB)) 1377 return false; 1378 1379 return StatBufA.st_ino == StatBufB.st_ino; 1380} 1381 1382std::pair<unsigned, unsigned> 1383HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) { 1384 unsigned KeyLen = (unsigned) clang::io::ReadUnalignedLE16(d); 1385 unsigned DataLen = (unsigned) *d++; 1386 return std::make_pair(KeyLen + 1, DataLen); 1387} 1388 1389HeaderFileInfoTrait::data_type 1390HeaderFileInfoTrait::ReadData(const internal_key_type, const unsigned char *d, 1391 unsigned DataLen) { 1392 const unsigned char *End = d + DataLen; 1393 using namespace clang::io; 1394 HeaderFileInfo HFI; 1395 unsigned Flags = *d++; 1396 HFI.isImport = (Flags >> 5) & 0x01; 1397 HFI.isPragmaOnce = (Flags >> 4) & 0x01; 1398 HFI.DirInfo = (Flags >> 2) & 0x03; 1399 HFI.Resolved = (Flags >> 1) & 0x01; 1400 HFI.IndexHeaderMapHeader = Flags & 0x01; 1401 HFI.NumIncludes = ReadUnalignedLE16(d); 1402 HFI.ControllingMacroID = Reader.getGlobalDeclID(M, ReadUnalignedLE32(d)); 1403 if (unsigned FrameworkOffset = ReadUnalignedLE32(d)) { 1404 // The framework offset is 1 greater than the actual offset, 1405 // since 0 is used as an indicator for "no framework name". 1406 StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1); 1407 HFI.Framework = HS->getUniqueFrameworkName(FrameworkName); 1408 } 1409 1410 assert(End == d && "Wrong data length in HeaderFileInfo deserialization"); 1411 (void)End; 1412 1413 // This HeaderFileInfo was externally loaded. 1414 HFI.External = true; 1415 return HFI; 1416} 1417 1418void ASTReader::SetIdentifierIsMacro(IdentifierInfo *II, Module &F, 1419 uint64_t LocalOffset) { 1420 // Note that this identifier has a macro definition. 1421 II->setHasMacroDefinition(true); 1422 1423 // Adjust the offset to a global offset. 1424 UnreadMacroRecordOffsets[II] = F.GlobalBitOffset + LocalOffset; 1425} 1426 1427void ASTReader::ReadDefinedMacros() { 1428 for (ModuleReverseIterator I = ModuleMgr.rbegin(), 1429 E = ModuleMgr.rend(); I != E; ++I) { 1430 llvm::BitstreamCursor &MacroCursor = (*I)->MacroCursor; 1431 1432 // If there was no preprocessor block, skip this file. 1433 if (!MacroCursor.getBitStreamReader()) 1434 continue; 1435 1436 llvm::BitstreamCursor Cursor = MacroCursor; 1437 Cursor.JumpToBit((*I)->MacroStartOffset); 1438 1439 RecordData Record; 1440 while (true) { 1441 unsigned Code = Cursor.ReadCode(); 1442 if (Code == llvm::bitc::END_BLOCK) 1443 break; 1444 1445 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1446 // No known subblocks, always skip them. 1447 Cursor.ReadSubBlockID(); 1448 if (Cursor.SkipBlock()) { 1449 Error("malformed block record in AST file"); 1450 return; 1451 } 1452 continue; 1453 } 1454 1455 if (Code == llvm::bitc::DEFINE_ABBREV) { 1456 Cursor.ReadAbbrevRecord(); 1457 continue; 1458 } 1459 1460 // Read a record. 1461 const char *BlobStart; 1462 unsigned BlobLen; 1463 Record.clear(); 1464 switch (Cursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 1465 default: // Default behavior: ignore. 1466 break; 1467 1468 case PP_MACRO_OBJECT_LIKE: 1469 case PP_MACRO_FUNCTION_LIKE: 1470 getLocalIdentifier(**I, Record[0]); 1471 break; 1472 1473 case PP_TOKEN: 1474 // Ignore tokens. 1475 break; 1476 } 1477 } 1478 } 1479 1480 // Drain the unread macro-record offsets map. 1481 while (!UnreadMacroRecordOffsets.empty()) 1482 LoadMacroDefinition(UnreadMacroRecordOffsets.begin()); 1483} 1484 1485void ASTReader::LoadMacroDefinition( 1486 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos) { 1487 assert(Pos != UnreadMacroRecordOffsets.end() && "Unknown macro definition"); 1488 uint64_t Offset = Pos->second; 1489 UnreadMacroRecordOffsets.erase(Pos); 1490 1491 RecordLocation Loc = getLocalBitOffset(Offset); 1492 ReadMacroRecord(*Loc.F, Loc.Offset); 1493} 1494 1495void ASTReader::LoadMacroDefinition(IdentifierInfo *II) { 1496 llvm::DenseMap<IdentifierInfo *, uint64_t>::iterator Pos 1497 = UnreadMacroRecordOffsets.find(II); 1498 LoadMacroDefinition(Pos); 1499} 1500 1501const FileEntry *ASTReader::getFileEntry(StringRef filenameStrRef) { 1502 std::string Filename = filenameStrRef; 1503 MaybeAddSystemRootToFilename(Filename); 1504 const FileEntry *File = FileMgr.getFile(Filename); 1505 if (File == 0 && !OriginalDir.empty() && !CurrentDir.empty() && 1506 OriginalDir != CurrentDir) { 1507 std::string resolved = resolveFileRelativeToOriginalDir(Filename, 1508 OriginalDir, 1509 CurrentDir); 1510 if (!resolved.empty()) 1511 File = FileMgr.getFile(resolved); 1512 } 1513 1514 return File; 1515} 1516 1517/// \brief If we are loading a relocatable PCH file, and the filename is 1518/// not an absolute path, add the system root to the beginning of the file 1519/// name. 1520void ASTReader::MaybeAddSystemRootToFilename(std::string &Filename) { 1521 // If this is not a relocatable PCH file, there's nothing to do. 1522 if (!RelocatablePCH) 1523 return; 1524 1525 if (Filename.empty() || llvm::sys::path::is_absolute(Filename)) 1526 return; 1527 1528 if (isysroot.empty()) { 1529 // If no system root was given, default to '/' 1530 Filename.insert(Filename.begin(), '/'); 1531 return; 1532 } 1533 1534 unsigned Length = isysroot.size(); 1535 if (isysroot[Length - 1] != '/') 1536 Filename.insert(Filename.begin(), '/'); 1537 1538 Filename.insert(Filename.begin(), isysroot.begin(), isysroot.end()); 1539} 1540 1541ASTReader::ASTReadResult 1542ASTReader::ReadASTBlock(Module &F) { 1543 llvm::BitstreamCursor &Stream = F.Stream; 1544 1545 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 1546 Error("malformed block record in AST file"); 1547 return Failure; 1548 } 1549 1550 // Read all of the records and blocks for the ASt file. 1551 RecordData Record; 1552 while (!Stream.AtEndOfStream()) { 1553 unsigned Code = Stream.ReadCode(); 1554 if (Code == llvm::bitc::END_BLOCK) { 1555 if (Stream.ReadBlockEnd()) { 1556 Error("error at end of module block in AST file"); 1557 return Failure; 1558 } 1559 1560 return Success; 1561 } 1562 1563 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 1564 switch (Stream.ReadSubBlockID()) { 1565 case DECLTYPES_BLOCK_ID: 1566 // We lazily load the decls block, but we want to set up the 1567 // DeclsCursor cursor to point into it. Clone our current bitcode 1568 // cursor to it, enter the block and read the abbrevs in that block. 1569 // With the main cursor, we just skip over it. 1570 F.DeclsCursor = Stream; 1571 if (Stream.SkipBlock() || // Skip with the main cursor. 1572 // Read the abbrevs. 1573 ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) { 1574 Error("malformed block record in AST file"); 1575 return Failure; 1576 } 1577 break; 1578 1579 case DECL_UPDATES_BLOCK_ID: 1580 if (Stream.SkipBlock()) { 1581 Error("malformed block record in AST file"); 1582 return Failure; 1583 } 1584 break; 1585 1586 case PREPROCESSOR_BLOCK_ID: 1587 F.MacroCursor = Stream; 1588 if (!PP.getExternalSource()) 1589 PP.setExternalSource(this); 1590 1591 if (Stream.SkipBlock() || 1592 ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) { 1593 Error("malformed block record in AST file"); 1594 return Failure; 1595 } 1596 F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo(); 1597 break; 1598 1599 case PREPROCESSOR_DETAIL_BLOCK_ID: 1600 F.PreprocessorDetailCursor = Stream; 1601 if (Stream.SkipBlock() || 1602 ReadBlockAbbrevs(F.PreprocessorDetailCursor, 1603 PREPROCESSOR_DETAIL_BLOCK_ID)) { 1604 Error("malformed preprocessor detail record in AST file"); 1605 return Failure; 1606 } 1607 F.PreprocessorDetailStartOffset 1608 = F.PreprocessorDetailCursor.GetCurrentBitNo(); 1609 1610 if (!PP.getPreprocessingRecord()) 1611 PP.createPreprocessingRecord(true); 1612 if (!PP.getPreprocessingRecord()->getExternalSource()) 1613 PP.getPreprocessingRecord()->SetExternalSource(*this); 1614 break; 1615 1616 case SOURCE_MANAGER_BLOCK_ID: 1617 switch (ReadSourceManagerBlock(F)) { 1618 case Success: 1619 break; 1620 1621 case Failure: 1622 Error("malformed source manager block in AST file"); 1623 return Failure; 1624 1625 case IgnorePCH: 1626 return IgnorePCH; 1627 } 1628 break; 1629 } 1630 continue; 1631 } 1632 1633 if (Code == llvm::bitc::DEFINE_ABBREV) { 1634 Stream.ReadAbbrevRecord(); 1635 continue; 1636 } 1637 1638 // Read and process a record. 1639 Record.clear(); 1640 const char *BlobStart = 0; 1641 unsigned BlobLen = 0; 1642 switch ((ASTRecordTypes)Stream.ReadRecord(Code, Record, 1643 &BlobStart, &BlobLen)) { 1644 default: // Default behavior: ignore. 1645 break; 1646 1647 case METADATA: { 1648 if (Record[0] != VERSION_MAJOR && !DisableValidation) { 1649 Diag(Record[0] < VERSION_MAJOR? diag::warn_pch_version_too_old 1650 : diag::warn_pch_version_too_new); 1651 return IgnorePCH; 1652 } 1653 1654 RelocatablePCH = Record[4]; 1655 if (Listener) { 1656 std::string TargetTriple(BlobStart, BlobLen); 1657 if (Listener->ReadTargetTriple(TargetTriple)) 1658 return IgnorePCH; 1659 } 1660 break; 1661 } 1662 1663 case IMPORTS: { 1664 // Load each of the imported PCH files. 1665 unsigned Idx = 0, N = Record.size(); 1666 while (Idx < N) { 1667 // Read information about the AST file. 1668 ModuleKind ImportedKind = (ModuleKind)Record[Idx++]; 1669 unsigned Length = Record[Idx++]; 1670 llvm::SmallString<128> ImportedFile(Record.begin() + Idx, 1671 Record.begin() + Idx + Length); 1672 Idx += Length; 1673 1674 // Load the AST file. 1675 switch(ReadASTCore(ImportedFile, ImportedKind, &F)) { 1676 case Failure: return Failure; 1677 // If we have to ignore the dependency, we'll have to ignore this too. 1678 case IgnorePCH: return IgnorePCH; 1679 case Success: break; 1680 } 1681 } 1682 break; 1683 } 1684 1685 case TYPE_OFFSET: { 1686 if (F.LocalNumTypes != 0) { 1687 Error("duplicate TYPE_OFFSET record in AST file"); 1688 return Failure; 1689 } 1690 F.TypeOffsets = (const uint32_t *)BlobStart; 1691 F.LocalNumTypes = Record[0]; 1692 unsigned LocalBaseTypeIndex = Record[1]; 1693 F.BaseTypeIndex = getTotalNumTypes(); 1694 1695 if (F.LocalNumTypes > 0) { 1696 // Introduce the global -> local mapping for types within this module. 1697 GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F)); 1698 1699 // Introduce the local -> global mapping for types within this module. 1700 F.TypeRemap.insert(std::make_pair(LocalBaseTypeIndex, 1701 F.BaseTypeIndex - LocalBaseTypeIndex)); 1702 1703 TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes); 1704 } 1705 break; 1706 } 1707 1708 case DECL_OFFSET: { 1709 if (F.LocalNumDecls != 0) { 1710 Error("duplicate DECL_OFFSET record in AST file"); 1711 return Failure; 1712 } 1713 F.DeclOffsets = (const uint32_t *)BlobStart; 1714 F.LocalNumDecls = Record[0]; 1715 unsigned LocalBaseDeclID = Record[1]; 1716 F.BaseDeclID = getTotalNumDecls(); 1717 1718 if (F.LocalNumDecls > 0) { 1719 // Introduce the global -> local mapping for declarations within this 1720 // module. 1721 GlobalDeclMap.insert( 1722 std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F)); 1723 1724 // Introduce the local -> global mapping for declarations within this 1725 // module. 1726 F.DeclRemap.insert(std::make_pair(LocalBaseDeclID, 1727 F.BaseDeclID - LocalBaseDeclID)); 1728 1729 DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls); 1730 } 1731 break; 1732 } 1733 1734 case TU_UPDATE_LEXICAL: { 1735 DeclContext *TU = Context.getTranslationUnitDecl(); 1736 DeclContextInfo &Info = F.DeclContextInfos[TU]; 1737 Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(BlobStart); 1738 Info.NumLexicalDecls 1739 = static_cast<unsigned int>(BlobLen / sizeof(KindDeclIDPair)); 1740 TU->setHasExternalLexicalStorage(true); 1741 break; 1742 } 1743 1744 case UPDATE_VISIBLE: { 1745 unsigned Idx = 0; 1746 serialization::DeclID ID = ReadDeclID(F, Record, Idx); 1747 void *Table = ASTDeclContextNameLookupTable::Create( 1748 (const unsigned char *)BlobStart + Record[Idx++], 1749 (const unsigned char *)BlobStart, 1750 ASTDeclContextNameLookupTrait(*this, F)); 1751 if (ID == PREDEF_DECL_TRANSLATION_UNIT_ID) { // Is it the TU? 1752 DeclContext *TU = Context.getTranslationUnitDecl(); 1753 F.DeclContextInfos[TU].NameLookupTableData = Table; 1754 TU->setHasExternalVisibleStorage(true); 1755 } else 1756 PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F)); 1757 break; 1758 } 1759 1760 case REDECLS_UPDATE_LATEST: { 1761 assert(Record.size() % 2 == 0 && "Expected pairs of DeclIDs"); 1762 for (unsigned i = 0, e = Record.size(); i < e; /* in loop */) { 1763 DeclID First = ReadDeclID(F, Record, i); 1764 DeclID Latest = ReadDeclID(F, Record, i); 1765 FirstLatestDeclIDs[First] = Latest; 1766 } 1767 break; 1768 } 1769 1770 case LANGUAGE_OPTIONS: 1771 if (ParseLanguageOptions(Record) && !DisableValidation) 1772 return IgnorePCH; 1773 break; 1774 1775 case IDENTIFIER_TABLE: 1776 F.IdentifierTableData = BlobStart; 1777 if (Record[0]) { 1778 F.IdentifierLookupTable 1779 = ASTIdentifierLookupTable::Create( 1780 (const unsigned char *)F.IdentifierTableData + Record[0], 1781 (const unsigned char *)F.IdentifierTableData, 1782 ASTIdentifierLookupTrait(*this, F)); 1783 1784 PP.getIdentifierTable().setExternalIdentifierLookup(this); 1785 } 1786 break; 1787 1788 case IDENTIFIER_OFFSET: { 1789 if (F.LocalNumIdentifiers != 0) { 1790 Error("duplicate IDENTIFIER_OFFSET record in AST file"); 1791 return Failure; 1792 } 1793 F.IdentifierOffsets = (const uint32_t *)BlobStart; 1794 F.LocalNumIdentifiers = Record[0]; 1795 unsigned LocalBaseIdentifierID = Record[1]; 1796 F.BaseIdentifierID = getTotalNumIdentifiers(); 1797 1798 if (F.LocalNumIdentifiers > 0) { 1799 // Introduce the global -> local mapping for identifiers within this 1800 // module. 1801 GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1, 1802 &F)); 1803 1804 // Introduce the local -> global mapping for identifiers within this 1805 // module. 1806 F.IdentifierRemap.insert( 1807 std::make_pair(LocalBaseIdentifierID, 1808 F.BaseIdentifierID - LocalBaseIdentifierID)); 1809 1810 IdentifiersLoaded.resize(IdentifiersLoaded.size() 1811 + F.LocalNumIdentifiers); 1812 } 1813 break; 1814 } 1815 1816 case EXTERNAL_DEFINITIONS: 1817 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1818 ExternalDefinitions.push_back(getGlobalDeclID(F, Record[I])); 1819 break; 1820 1821 case SPECIAL_TYPES: 1822 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1823 SpecialTypes.push_back(getGlobalTypeID(F, Record[I])); 1824 break; 1825 1826 case STATISTICS: 1827 TotalNumStatements += Record[0]; 1828 TotalNumMacros += Record[1]; 1829 TotalLexicalDeclContexts += Record[2]; 1830 TotalVisibleDeclContexts += Record[3]; 1831 break; 1832 1833 case UNUSED_FILESCOPED_DECLS: 1834 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1835 UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I])); 1836 break; 1837 1838 case DELEGATING_CTORS: 1839 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1840 DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I])); 1841 break; 1842 1843 case WEAK_UNDECLARED_IDENTIFIERS: 1844 if (Record.size() % 4 != 0) { 1845 Error("invalid weak identifiers record"); 1846 return Failure; 1847 } 1848 1849 // FIXME: Ignore weak undeclared identifiers from non-original PCH 1850 // files. This isn't the way to do it :) 1851 WeakUndeclaredIdentifiers.clear(); 1852 1853 // Translate the weak, undeclared identifiers into global IDs. 1854 for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) { 1855 WeakUndeclaredIdentifiers.push_back( 1856 getGlobalIdentifierID(F, Record[I++])); 1857 WeakUndeclaredIdentifiers.push_back( 1858 getGlobalIdentifierID(F, Record[I++])); 1859 WeakUndeclaredIdentifiers.push_back( 1860 ReadSourceLocation(F, Record, I).getRawEncoding()); 1861 WeakUndeclaredIdentifiers.push_back(Record[I++]); 1862 } 1863 break; 1864 1865 case LOCALLY_SCOPED_EXTERNAL_DECLS: 1866 for (unsigned I = 0, N = Record.size(); I != N; ++I) 1867 LocallyScopedExternalDecls.push_back(getGlobalDeclID(F, Record[I])); 1868 break; 1869 1870 case SELECTOR_OFFSETS: { 1871 F.SelectorOffsets = (const uint32_t *)BlobStart; 1872 F.LocalNumSelectors = Record[0]; 1873 unsigned LocalBaseSelectorID = Record[1]; 1874 F.BaseSelectorID = getTotalNumSelectors(); 1875 1876 if (F.LocalNumSelectors > 0) { 1877 // Introduce the global -> local mapping for selectors within this 1878 // module. 1879 GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F)); 1880 1881 // Introduce the local -> global mapping for selectors within this 1882 // module. 1883 F.SelectorRemap.insert(std::make_pair(LocalBaseSelectorID, 1884 F.BaseSelectorID - LocalBaseSelectorID)); 1885 1886 SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors); 1887 } 1888 break; 1889 } 1890 1891 case METHOD_POOL: 1892 F.SelectorLookupTableData = (const unsigned char *)BlobStart; 1893 if (Record[0]) 1894 F.SelectorLookupTable 1895 = ASTSelectorLookupTable::Create( 1896 F.SelectorLookupTableData + Record[0], 1897 F.SelectorLookupTableData, 1898 ASTSelectorLookupTrait(*this, F)); 1899 TotalNumMethodPoolEntries += Record[1]; 1900 break; 1901 1902 case REFERENCED_SELECTOR_POOL: 1903 if (!Record.empty()) { 1904 for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) { 1905 ReferencedSelectorsData.push_back(getGlobalSelectorID(F, 1906 Record[Idx++])); 1907 ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx). 1908 getRawEncoding()); 1909 } 1910 } 1911 break; 1912 1913 case PP_COUNTER_VALUE: 1914 if (!Record.empty() && Listener) 1915 Listener->ReadCounter(Record[0]); 1916 break; 1917 1918 case SOURCE_LOCATION_OFFSETS: { 1919 F.SLocEntryOffsets = (const uint32_t *)BlobStart; 1920 F.LocalNumSLocEntries = Record[0]; 1921 unsigned SLocSpaceSize = Record[1]; 1922 llvm::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) = 1923 SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries, 1924 SLocSpaceSize); 1925 // Make our entry in the range map. BaseID is negative and growing, so 1926 // we invert it. Because we invert it, though, we need the other end of 1927 // the range. 1928 unsigned RangeStart = 1929 unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1; 1930 GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F)); 1931 F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset); 1932 1933 // SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing. 1934 assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0); 1935 GlobalSLocOffsetMap.insert( 1936 std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset 1937 - SLocSpaceSize,&F)); 1938 1939 // Initialize the remapping table. 1940 // Invalid stays invalid. 1941 F.SLocRemap.insert(std::make_pair(0U, 0)); 1942 // This module. Base was 2 when being compiled. 1943 F.SLocRemap.insert(std::make_pair(2U, 1944 static_cast<int>(F.SLocEntryBaseOffset - 2))); 1945 1946 TotalNumSLocEntries += F.LocalNumSLocEntries; 1947 break; 1948 } 1949 1950 case MODULE_OFFSET_MAP: { 1951 // Additional remapping information. 1952 const unsigned char *Data = (const unsigned char*)BlobStart; 1953 const unsigned char *DataEnd = Data + BlobLen; 1954 1955 // Continuous range maps we may be updating in our module. 1956 ContinuousRangeMap<uint32_t, int, 2>::Builder SLocRemap(F.SLocRemap); 1957 ContinuousRangeMap<uint32_t, int, 2>::Builder 1958 IdentifierRemap(F.IdentifierRemap); 1959 ContinuousRangeMap<uint32_t, int, 2>::Builder 1960 PreprocessedEntityRemap(F.PreprocessedEntityRemap); 1961 ContinuousRangeMap<uint32_t, int, 2>::Builder 1962 SelectorRemap(F.SelectorRemap); 1963 ContinuousRangeMap<uint32_t, int, 2>::Builder DeclRemap(F.DeclRemap); 1964 ContinuousRangeMap<uint32_t, int, 2>::Builder TypeRemap(F.TypeRemap); 1965 1966 while(Data < DataEnd) { 1967 uint16_t Len = io::ReadUnalignedLE16(Data); 1968 StringRef Name = StringRef((const char*)Data, Len); 1969 Data += Len; 1970 Module *OM = ModuleMgr.lookup(Name); 1971 if (!OM) { 1972 Error("SourceLocation remap refers to unknown module"); 1973 return Failure; 1974 } 1975 1976 uint32_t SLocOffset = io::ReadUnalignedLE32(Data); 1977 uint32_t IdentifierIDOffset = io::ReadUnalignedLE32(Data); 1978 uint32_t PreprocessedEntityIDOffset = io::ReadUnalignedLE32(Data); 1979 uint32_t SelectorIDOffset = io::ReadUnalignedLE32(Data); 1980 uint32_t DeclIDOffset = io::ReadUnalignedLE32(Data); 1981 uint32_t TypeIndexOffset = io::ReadUnalignedLE32(Data); 1982 1983 // Source location offset is mapped to OM->SLocEntryBaseOffset. 1984 SLocRemap.insert(std::make_pair(SLocOffset, 1985 static_cast<int>(OM->SLocEntryBaseOffset - SLocOffset))); 1986 IdentifierRemap.insert( 1987 std::make_pair(IdentifierIDOffset, 1988 OM->BaseIdentifierID - IdentifierIDOffset)); 1989 PreprocessedEntityRemap.insert( 1990 std::make_pair(PreprocessedEntityIDOffset, 1991 OM->BasePreprocessedEntityID - PreprocessedEntityIDOffset)); 1992 SelectorRemap.insert(std::make_pair(SelectorIDOffset, 1993 OM->BaseSelectorID - SelectorIDOffset)); 1994 DeclRemap.insert(std::make_pair(DeclIDOffset, 1995 OM->BaseDeclID - DeclIDOffset)); 1996 1997 TypeRemap.insert(std::make_pair(TypeIndexOffset, 1998 OM->BaseTypeIndex - TypeIndexOffset)); 1999 } 2000 break; 2001 } 2002 2003 case SOURCE_MANAGER_LINE_TABLE: 2004 if (ParseLineTable(F, Record)) 2005 return Failure; 2006 break; 2007 2008 case FILE_SOURCE_LOCATION_OFFSETS: 2009 F.SLocFileOffsets = (const uint32_t *)BlobStart; 2010 F.LocalNumSLocFileEntries = Record[0]; 2011 break; 2012 2013 case SOURCE_LOCATION_PRELOADS: { 2014 // Need to transform from the local view (1-based IDs) to the global view, 2015 // which is based off F.SLocEntryBaseID. 2016 if (!F.PreloadSLocEntries.empty()) { 2017 Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file"); 2018 return Failure; 2019 } 2020 2021 F.PreloadSLocEntries.swap(Record); 2022 break; 2023 } 2024 2025 case STAT_CACHE: { 2026 if (!DisableStatCache) { 2027 ASTStatCache *MyStatCache = 2028 new ASTStatCache((const unsigned char *)BlobStart + Record[0], 2029 (const unsigned char *)BlobStart, 2030 NumStatHits, NumStatMisses); 2031 FileMgr.addStatCache(MyStatCache); 2032 F.StatCache = MyStatCache; 2033 } 2034 break; 2035 } 2036 2037 case EXT_VECTOR_DECLS: 2038 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2039 ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I])); 2040 break; 2041 2042 case VTABLE_USES: 2043 if (Record.size() % 3 != 0) { 2044 Error("Invalid VTABLE_USES record"); 2045 return Failure; 2046 } 2047 2048 // Later tables overwrite earlier ones. 2049 // FIXME: Modules will have some trouble with this. This is clearly not 2050 // the right way to do this. 2051 VTableUses.clear(); 2052 2053 for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) { 2054 VTableUses.push_back(getGlobalDeclID(F, Record[Idx++])); 2055 VTableUses.push_back( 2056 ReadSourceLocation(F, Record, Idx).getRawEncoding()); 2057 VTableUses.push_back(Record[Idx++]); 2058 } 2059 break; 2060 2061 case DYNAMIC_CLASSES: 2062 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2063 DynamicClasses.push_back(getGlobalDeclID(F, Record[I])); 2064 break; 2065 2066 case PENDING_IMPLICIT_INSTANTIATIONS: 2067 if (PendingInstantiations.size() % 2 != 0) { 2068 Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block"); 2069 return Failure; 2070 } 2071 2072 // Later lists of pending instantiations overwrite earlier ones. 2073 // FIXME: This is most certainly wrong for modules. 2074 PendingInstantiations.clear(); 2075 for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) { 2076 PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++])); 2077 PendingInstantiations.push_back( 2078 ReadSourceLocation(F, Record, I).getRawEncoding()); 2079 } 2080 break; 2081 2082 case SEMA_DECL_REFS: 2083 // Later tables overwrite earlier ones. 2084 // FIXME: Modules will have some trouble with this. 2085 SemaDeclRefs.clear(); 2086 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2087 SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2088 break; 2089 2090 case ORIGINAL_FILE_NAME: 2091 // The primary AST will be the last to get here, so it will be the one 2092 // that's used. 2093 ActualOriginalFileName.assign(BlobStart, BlobLen); 2094 OriginalFileName = ActualOriginalFileName; 2095 MaybeAddSystemRootToFilename(OriginalFileName); 2096 break; 2097 2098 case ORIGINAL_FILE_ID: 2099 OriginalFileID = FileID::get(Record[0]); 2100 break; 2101 2102 case ORIGINAL_PCH_DIR: 2103 // The primary AST will be the last to get here, so it will be the one 2104 // that's used. 2105 OriginalDir.assign(BlobStart, BlobLen); 2106 break; 2107 2108 case VERSION_CONTROL_BRANCH_REVISION: { 2109 const std::string &CurBranch = getClangFullRepositoryVersion(); 2110 StringRef ASTBranch(BlobStart, BlobLen); 2111 if (StringRef(CurBranch) != ASTBranch && !DisableValidation) { 2112 Diag(diag::warn_pch_different_branch) << ASTBranch << CurBranch; 2113 return IgnorePCH; 2114 } 2115 break; 2116 } 2117 2118 case PPD_ENTITIES_OFFSETS: { 2119 F.PreprocessedEntityOffsets = (const PPEntityOffset *)BlobStart; 2120 assert(BlobLen % sizeof(PPEntityOffset) == 0); 2121 F.NumPreprocessedEntities = BlobLen / sizeof(PPEntityOffset); 2122 2123 unsigned LocalBasePreprocessedEntityID = Record[0]; 2124 2125 unsigned StartingID; 2126 if (!PP.getPreprocessingRecord()) 2127 PP.createPreprocessingRecord(true); 2128 if (!PP.getPreprocessingRecord()->getExternalSource()) 2129 PP.getPreprocessingRecord()->SetExternalSource(*this); 2130 StartingID 2131 = PP.getPreprocessingRecord() 2132 ->allocateLoadedEntities(F.NumPreprocessedEntities); 2133 F.BasePreprocessedEntityID = StartingID; 2134 2135 if (F.NumPreprocessedEntities > 0) { 2136 // Introduce the global -> local mapping for preprocessed entities in 2137 // this module. 2138 GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F)); 2139 2140 // Introduce the local -> global mapping for preprocessed entities in 2141 // this module. 2142 F.PreprocessedEntityRemap.insert( 2143 std::make_pair(LocalBasePreprocessedEntityID, 2144 F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID)); 2145 } 2146 2147 break; 2148 } 2149 2150 case DECL_UPDATE_OFFSETS: { 2151 if (Record.size() % 2 != 0) { 2152 Error("invalid DECL_UPDATE_OFFSETS block in AST file"); 2153 return Failure; 2154 } 2155 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2156 DeclUpdateOffsets[getGlobalDeclID(F, Record[I])] 2157 .push_back(std::make_pair(&F, Record[I+1])); 2158 break; 2159 } 2160 2161 case DECL_REPLACEMENTS: { 2162 if (Record.size() % 2 != 0) { 2163 Error("invalid DECL_REPLACEMENTS block in AST file"); 2164 return Failure; 2165 } 2166 for (unsigned I = 0, N = Record.size(); I != N; I += 2) 2167 ReplacedDecls[getGlobalDeclID(F, Record[I])] 2168 = std::make_pair(&F, Record[I+1]); 2169 break; 2170 } 2171 2172 case OBJC_CHAINED_CATEGORIES: { 2173 if (Record.size() % 3 != 0) { 2174 Error("invalid OBJC_CHAINED_CATEGORIES block in AST file"); 2175 return Failure; 2176 } 2177 for (unsigned I = 0, N = Record.size(); I != N; I += 3) { 2178 serialization::GlobalDeclID GlobID = getGlobalDeclID(F, Record[I]); 2179 F.ChainedObjCCategories[GlobID] = std::make_pair(Record[I+1], 2180 Record[I+2]); 2181 ObjCChainedCategoriesInterfaces.insert(GlobID); 2182 } 2183 break; 2184 } 2185 2186 case CXX_BASE_SPECIFIER_OFFSETS: { 2187 if (F.LocalNumCXXBaseSpecifiers != 0) { 2188 Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file"); 2189 return Failure; 2190 } 2191 2192 F.LocalNumCXXBaseSpecifiers = Record[0]; 2193 F.CXXBaseSpecifiersOffsets = (const uint32_t *)BlobStart; 2194 NumCXXBaseSpecifiersLoaded += F.LocalNumCXXBaseSpecifiers; 2195 break; 2196 } 2197 2198 case DIAG_PRAGMA_MAPPINGS: 2199 if (Record.size() % 2 != 0) { 2200 Error("invalid DIAG_USER_MAPPINGS block in AST file"); 2201 return Failure; 2202 } 2203 2204 if (F.PragmaDiagMappings.empty()) 2205 F.PragmaDiagMappings.swap(Record); 2206 else 2207 F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(), 2208 Record.begin(), Record.end()); 2209 break; 2210 2211 case CUDA_SPECIAL_DECL_REFS: 2212 // Later tables overwrite earlier ones. 2213 // FIXME: Modules will have trouble with this. 2214 CUDASpecialDeclRefs.clear(); 2215 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2216 CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I])); 2217 break; 2218 2219 case HEADER_SEARCH_TABLE: { 2220 F.HeaderFileInfoTableData = BlobStart; 2221 F.LocalNumHeaderFileInfos = Record[1]; 2222 F.HeaderFileFrameworkStrings = BlobStart + Record[2]; 2223 if (Record[0]) { 2224 F.HeaderFileInfoTable 2225 = HeaderFileInfoLookupTable::Create( 2226 (const unsigned char *)F.HeaderFileInfoTableData + Record[0], 2227 (const unsigned char *)F.HeaderFileInfoTableData, 2228 HeaderFileInfoTrait(*this, F, 2229 &PP.getHeaderSearchInfo(), 2230 BlobStart + Record[2])); 2231 2232 PP.getHeaderSearchInfo().SetExternalSource(this); 2233 if (!PP.getHeaderSearchInfo().getExternalLookup()) 2234 PP.getHeaderSearchInfo().SetExternalLookup(this); 2235 } 2236 break; 2237 } 2238 2239 case FP_PRAGMA_OPTIONS: 2240 // Later tables overwrite earlier ones. 2241 FPPragmaOptions.swap(Record); 2242 break; 2243 2244 case OPENCL_EXTENSIONS: 2245 // Later tables overwrite earlier ones. 2246 OpenCLExtensions.swap(Record); 2247 break; 2248 2249 case TENTATIVE_DEFINITIONS: 2250 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2251 TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I])); 2252 break; 2253 2254 case KNOWN_NAMESPACES: 2255 for (unsigned I = 0, N = Record.size(); I != N; ++I) 2256 KnownNamespaces.push_back(getGlobalDeclID(F, Record[I])); 2257 break; 2258 } 2259 } 2260 Error("premature end of bitstream in AST file"); 2261 return Failure; 2262} 2263 2264ASTReader::ASTReadResult ASTReader::validateFileEntries(Module &M) { 2265 llvm::BitstreamCursor &SLocEntryCursor = M.SLocEntryCursor; 2266 2267 for (unsigned i = 0, e = M.LocalNumSLocFileEntries; i != e; ++i) { 2268 SLocEntryCursor.JumpToBit(M.SLocFileOffsets[i]); 2269 unsigned Code = SLocEntryCursor.ReadCode(); 2270 if (Code == llvm::bitc::END_BLOCK || 2271 Code == llvm::bitc::ENTER_SUBBLOCK || 2272 Code == llvm::bitc::DEFINE_ABBREV) { 2273 Error("incorrectly-formatted source location entry in AST file"); 2274 return Failure; 2275 } 2276 2277 RecordData Record; 2278 const char *BlobStart; 2279 unsigned BlobLen; 2280 switch (SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { 2281 default: 2282 Error("incorrectly-formatted source location entry in AST file"); 2283 return Failure; 2284 2285 case SM_SLOC_FILE_ENTRY: { 2286 StringRef Filename(BlobStart, BlobLen); 2287 const FileEntry *File = getFileEntry(Filename); 2288 2289 if (File == 0) { 2290 std::string ErrorStr = "could not find file '"; 2291 ErrorStr += Filename; 2292 ErrorStr += "' referenced by AST file"; 2293 Error(ErrorStr.c_str()); 2294 return IgnorePCH; 2295 } 2296 2297 if (Record.size() < 6) { 2298 Error("source location entry is incorrect"); 2299 return Failure; 2300 } 2301 2302 // The stat info from the FileEntry came from the cached stat 2303 // info of the PCH, so we cannot trust it. 2304 struct stat StatBuf; 2305 if (::stat(File->getName(), &StatBuf) != 0) { 2306 StatBuf.st_size = File->getSize(); 2307 StatBuf.st_mtime = File->getModificationTime(); 2308 } 2309 2310 if (((off_t)Record[4] != StatBuf.st_size 2311#if !defined(LLVM_ON_WIN32) 2312 // In our regression testing, the Windows file system seems to 2313 // have inconsistent modification times that sometimes 2314 // erroneously trigger this error-handling path. 2315 || (time_t)Record[5] != StatBuf.st_mtime 2316#endif 2317 )) { 2318 Error(diag::err_fe_pch_file_modified, Filename); 2319 return IgnorePCH; 2320 } 2321 2322 break; 2323 } 2324 } 2325 } 2326 2327 return Success; 2328} 2329 2330namespace { 2331 /// \brief Visitor class used to look up identifirs in an AST file. 2332 class IdentifierLookupVisitor { 2333 StringRef Name; 2334 IdentifierInfo *Found; 2335 public: 2336 explicit IdentifierLookupVisitor(StringRef Name) : Name(Name), Found() { } 2337 2338 static bool visit(Module &M, void *UserData) { 2339 IdentifierLookupVisitor *This 2340 = static_cast<IdentifierLookupVisitor *>(UserData); 2341 2342 ASTIdentifierLookupTable *IdTable 2343 = (ASTIdentifierLookupTable *)M.IdentifierLookupTable; 2344 if (!IdTable) 2345 return false; 2346 2347 std::pair<const char*, unsigned> Key(This->Name.begin(), 2348 This->Name.size()); 2349 ASTIdentifierLookupTable::iterator Pos = IdTable->find(Key); 2350 if (Pos == IdTable->end()) 2351 return false; 2352 2353 // Dereferencing the iterator has the effect of building the 2354 // IdentifierInfo node and populating it with the various 2355 // declarations it needs. 2356 This->Found = *Pos; 2357 return true; 2358 } 2359 2360 // \brief Retrieve the identifier info found within the module 2361 // files. 2362 IdentifierInfo *getIdentifierInfo() const { return Found; } 2363 }; 2364} 2365 2366 2367ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName, 2368 ModuleKind Type) { 2369 switch(ReadASTCore(FileName, Type, /*ImportedBy=*/0)) { 2370 case Failure: return Failure; 2371 case IgnorePCH: return IgnorePCH; 2372 case Success: break; 2373 } 2374 2375 // Here comes stuff that we only do once the entire chain is loaded. 2376 2377 // Check the predefines buffers. 2378 if (!DisableValidation && Type != MK_Module && Type != MK_Preamble && 2379 // FIXME: CheckPredefinesBuffers also sets the SuggestedPredefines; 2380 // if DisableValidation is true, defines that were set on command-line 2381 // but not in the PCH file will not be added to SuggestedPredefines. 2382 CheckPredefinesBuffers()) 2383 return IgnorePCH; 2384 2385 // Initialization of keywords and pragmas occurs before the 2386 // AST file is read, so there may be some identifiers that were 2387 // loaded into the IdentifierTable before we intercepted the 2388 // creation of identifiers. Iterate through the list of known 2389 // identifiers and determine whether we have to establish 2390 // preprocessor definitions or top-level identifier declaration 2391 // chains for those identifiers. 2392 // 2393 // We copy the IdentifierInfo pointers to a small vector first, 2394 // since de-serializing declarations or macro definitions can add 2395 // new entries into the identifier table, invalidating the 2396 // iterators. 2397 // 2398 // FIXME: We need a lazier way to load this information, e.g., by marking 2399 // the identifier data as 'dirty', so that it will be looked up in the 2400 // AST file(s) if it is uttered in the source. This could save us some 2401 // module load time. 2402 SmallVector<IdentifierInfo *, 128> Identifiers; 2403 for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(), 2404 IdEnd = PP.getIdentifierTable().end(); 2405 Id != IdEnd; ++Id) 2406 Identifiers.push_back(Id->second); 2407 2408 for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { 2409 IdentifierLookupVisitor Visitor(Identifiers[I]->getName()); 2410 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 2411 } 2412 2413 InitializeContext(); 2414 2415 if (DeserializationListener) 2416 DeserializationListener->ReaderInitialized(this); 2417 2418 // If this AST file is a precompiled preamble, then set the preamble file ID 2419 // of the source manager to the file source file from which the preamble was 2420 // built. 2421 if (Type == MK_Preamble) { 2422 if (!OriginalFileID.isInvalid()) { 2423 OriginalFileID = FileID::get(ModuleMgr.getPrimaryModule().SLocEntryBaseID 2424 + OriginalFileID.getOpaqueValue() - 1); 2425 SourceMgr.setPreambleFileID(OriginalFileID); 2426 } 2427 } 2428 2429 return Success; 2430} 2431 2432ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, 2433 ModuleKind Type, 2434 Module *ImportedBy) { 2435 Module *M; 2436 bool NewModule; 2437 std::string ErrorStr; 2438 llvm::tie(M, NewModule) = ModuleMgr.addModule(FileName, Type, ImportedBy, 2439 ErrorStr); 2440 2441 if (!M) { 2442 // We couldn't load the module. 2443 std::string Msg = "Unable to load module \"" + FileName.str() + "\": " 2444 + ErrorStr; 2445 Error(Msg); 2446 return Failure; 2447 } 2448 2449 if (!NewModule) { 2450 // We've already loaded this module. 2451 return Success; 2452 } 2453 2454 // FIXME: This seems rather a hack. Should CurrentDir be part of the 2455 // module? 2456 if (FileName != "-") { 2457 CurrentDir = llvm::sys::path::parent_path(FileName); 2458 if (CurrentDir.empty()) CurrentDir = "."; 2459 } 2460 2461 Module &F = *M; 2462 llvm::BitstreamCursor &Stream = F.Stream; 2463 Stream.init(F.StreamFile); 2464 F.SizeInBits = F.Buffer->getBufferSize() * 8; 2465 2466 // Sniff for the signature. 2467 if (Stream.Read(8) != 'C' || 2468 Stream.Read(8) != 'P' || 2469 Stream.Read(8) != 'C' || 2470 Stream.Read(8) != 'H') { 2471 Diag(diag::err_not_a_pch_file) << FileName; 2472 return Failure; 2473 } 2474 2475 while (!Stream.AtEndOfStream()) { 2476 unsigned Code = Stream.ReadCode(); 2477 2478 if (Code != llvm::bitc::ENTER_SUBBLOCK) { 2479 Error("invalid record at top-level of AST file"); 2480 return Failure; 2481 } 2482 2483 unsigned BlockID = Stream.ReadSubBlockID(); 2484 2485 // We only know the AST subblock ID. 2486 switch (BlockID) { 2487 case llvm::bitc::BLOCKINFO_BLOCK_ID: 2488 if (Stream.ReadBlockInfoBlock()) { 2489 Error("malformed BlockInfoBlock in AST file"); 2490 return Failure; 2491 } 2492 break; 2493 case AST_BLOCK_ID: 2494 switch (ReadASTBlock(F)) { 2495 case Success: 2496 break; 2497 2498 case Failure: 2499 return Failure; 2500 2501 case IgnorePCH: 2502 // FIXME: We could consider reading through to the end of this 2503 // AST block, skipping subblocks, to see if there are other 2504 // AST blocks elsewhere. 2505 2506 // FIXME: We can't clear loaded slocentries anymore. 2507 //SourceMgr.ClearPreallocatedSLocEntries(); 2508 2509 // Remove the stat cache. 2510 if (F.StatCache) 2511 FileMgr.removeStatCache((ASTStatCache*)F.StatCache); 2512 2513 return IgnorePCH; 2514 } 2515 break; 2516 default: 2517 if (Stream.SkipBlock()) { 2518 Error("malformed block record in AST file"); 2519 return Failure; 2520 } 2521 break; 2522 } 2523 } 2524 2525 // Once read, set the Module bit base offset and update the size in 2526 // bits of all files we've seen. 2527 F.GlobalBitOffset = TotalModulesSizeInBits; 2528 TotalModulesSizeInBits += F.SizeInBits; 2529 GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F)); 2530 2531 // Make sure that the files this module was built against are still available. 2532 if (!DisableValidation) { 2533 switch(validateFileEntries(*M)) { 2534 case Failure: return Failure; 2535 case IgnorePCH: return IgnorePCH; 2536 case Success: break; 2537 } 2538 } 2539 2540 // Preload SLocEntries. 2541 for (unsigned I = 0, N = M->PreloadSLocEntries.size(); I != N; ++I) { 2542 int Index = int(M->PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID; 2543 // Load it through the SourceManager and don't call ReadSLocEntryRecord() 2544 // directly because the entry may have already been loaded in which case 2545 // calling ReadSLocEntryRecord() directly would trigger an assertion in 2546 // SourceManager. 2547 SourceMgr.getLoadedSLocEntryByID(Index); 2548 } 2549 2550 2551 return Success; 2552} 2553 2554void ASTReader::InitializeContext() { 2555 // If there's a listener, notify them that we "read" the translation unit. 2556 if (DeserializationListener) 2557 DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID, 2558 Context.getTranslationUnitDecl()); 2559 2560 // Make sure we load the declaration update records for the translation unit, 2561 // if there are any. 2562 loadDeclUpdateRecords(PREDEF_DECL_TRANSLATION_UNIT_ID, 2563 Context.getTranslationUnitDecl()); 2564 2565 // FIXME: Find a better way to deal with collisions between these 2566 // built-in types. Right now, we just ignore the problem. 2567 2568 // Load the special types. 2569 if (SpecialTypes.size() > NumSpecialTypeIDs) { 2570 if (Context.getBuiltinVaListType().isNull()) { 2571 Context.setBuiltinVaListType( 2572 GetType(SpecialTypes[SPECIAL_TYPE_BUILTIN_VA_LIST])); 2573 } 2574 2575 if (unsigned Proto = SpecialTypes[SPECIAL_TYPE_OBJC_PROTOCOL]) { 2576 if (Context.ObjCProtoType.isNull()) 2577 Context.ObjCProtoType = GetType(Proto); 2578 } 2579 2580 if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) { 2581 if (!Context.CFConstantStringTypeDecl) 2582 Context.setCFConstantStringType(GetType(String)); 2583 } 2584 2585 if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) { 2586 QualType FileType = GetType(File); 2587 if (FileType.isNull()) { 2588 Error("FILE type is NULL"); 2589 return; 2590 } 2591 2592 if (!Context.FILEDecl) { 2593 if (const TypedefType *Typedef = FileType->getAs<TypedefType>()) 2594 Context.setFILEDecl(Typedef->getDecl()); 2595 else { 2596 const TagType *Tag = FileType->getAs<TagType>(); 2597 if (!Tag) { 2598 Error("Invalid FILE type in AST file"); 2599 return; 2600 } 2601 Context.setFILEDecl(Tag->getDecl()); 2602 } 2603 } 2604 } 2605 2606 if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_jmp_buf]) { 2607 QualType Jmp_bufType = GetType(Jmp_buf); 2608 if (Jmp_bufType.isNull()) { 2609 Error("jmp_buf type is NULL"); 2610 return; 2611 } 2612 2613 if (!Context.jmp_bufDecl) { 2614 if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>()) 2615 Context.setjmp_bufDecl(Typedef->getDecl()); 2616 else { 2617 const TagType *Tag = Jmp_bufType->getAs<TagType>(); 2618 if (!Tag) { 2619 Error("Invalid jmp_buf type in AST file"); 2620 return; 2621 } 2622 Context.setjmp_bufDecl(Tag->getDecl()); 2623 } 2624 } 2625 } 2626 2627 if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_sigjmp_buf]) { 2628 QualType Sigjmp_bufType = GetType(Sigjmp_buf); 2629 if (Sigjmp_bufType.isNull()) { 2630 Error("sigjmp_buf type is NULL"); 2631 return; 2632 } 2633 2634 if (!Context.sigjmp_bufDecl) { 2635 if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>()) 2636 Context.setsigjmp_bufDecl(Typedef->getDecl()); 2637 else { 2638 const TagType *Tag = Sigjmp_bufType->getAs<TagType>(); 2639 assert(Tag && "Invalid sigjmp_buf type in AST file"); 2640 Context.setsigjmp_bufDecl(Tag->getDecl()); 2641 } 2642 } 2643 } 2644 2645 if (unsigned ObjCIdRedef 2646 = SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) { 2647 if (Context.ObjCIdRedefinitionType.isNull()) 2648 Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef); 2649 } 2650 2651 if (unsigned ObjCClassRedef 2652 = SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) { 2653 if (Context.ObjCClassRedefinitionType.isNull()) 2654 Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef); 2655 } 2656 2657 if (unsigned ObjCSelRedef 2658 = SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) { 2659 if (Context.ObjCSelRedefinitionType.isNull()) 2660 Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef); 2661 } 2662 } 2663 2664 ReadPragmaDiagnosticMappings(Context.getDiagnostics()); 2665 2666 // If there were any CUDA special declarations, deserialize them. 2667 if (!CUDASpecialDeclRefs.empty()) { 2668 assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!"); 2669 Context.setcudaConfigureCallDecl( 2670 cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0]))); 2671 } 2672} 2673 2674/// \brief Retrieve the name of the original source file name 2675/// directly from the AST file, without actually loading the AST 2676/// file. 2677std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName, 2678 FileManager &FileMgr, 2679 DiagnosticsEngine &Diags) { 2680 // Open the AST file. 2681 std::string ErrStr; 2682 llvm::OwningPtr<llvm::MemoryBuffer> Buffer; 2683 Buffer.reset(FileMgr.getBufferForFile(ASTFileName, &ErrStr)); 2684 if (!Buffer) { 2685 Diags.Report(diag::err_fe_unable_to_read_pch_file) << ErrStr; 2686 return std::string(); 2687 } 2688 2689 // Initialize the stream 2690 llvm::BitstreamReader StreamFile; 2691 llvm::BitstreamCursor Stream; 2692 StreamFile.init((const unsigned char *)Buffer->getBufferStart(), 2693 (const unsigned char *)Buffer->getBufferEnd()); 2694 Stream.init(StreamFile); 2695 2696 // Sniff for the signature. 2697 if (Stream.Read(8) != 'C' || 2698 Stream.Read(8) != 'P' || 2699 Stream.Read(8) != 'C' || 2700 Stream.Read(8) != 'H') { 2701 Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName; 2702 return std::string(); 2703 } 2704 2705 RecordData Record; 2706 while (!Stream.AtEndOfStream()) { 2707 unsigned Code = Stream.ReadCode(); 2708 2709 if (Code == llvm::bitc::ENTER_SUBBLOCK) { 2710 unsigned BlockID = Stream.ReadSubBlockID(); 2711 2712 // We only know the AST subblock ID. 2713 switch (BlockID) { 2714 case AST_BLOCK_ID: 2715 if (Stream.EnterSubBlock(AST_BLOCK_ID)) { 2716 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2717 return std::string(); 2718 } 2719 break; 2720 2721 default: 2722 if (Stream.SkipBlock()) { 2723 Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName; 2724 return std::string(); 2725 } 2726 break; 2727 } 2728 continue; 2729 } 2730 2731 if (Code == llvm::bitc::END_BLOCK) { 2732 if (Stream.ReadBlockEnd()) { 2733 Diags.Report(diag::err_fe_pch_error_at_end_block) << ASTFileName; 2734 return std::string(); 2735 } 2736 continue; 2737 } 2738 2739 if (Code == llvm::bitc::DEFINE_ABBREV) { 2740 Stream.ReadAbbrevRecord(); 2741 continue; 2742 } 2743 2744 Record.clear(); 2745 const char *BlobStart = 0; 2746 unsigned BlobLen = 0; 2747 if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) 2748 == ORIGINAL_FILE_NAME) 2749 return std::string(BlobStart, BlobLen); 2750 } 2751 2752 return std::string(); 2753} 2754 2755/// \brief Parse the record that corresponds to a LangOptions data 2756/// structure. 2757/// 2758/// This routine parses the language options from the AST file and then gives 2759/// them to the AST listener if one is set. 2760/// 2761/// \returns true if the listener deems the file unacceptable, false otherwise. 2762bool ASTReader::ParseLanguageOptions( 2763 const SmallVectorImpl<uint64_t> &Record) { 2764 if (Listener) { 2765 LangOptions LangOpts; 2766 unsigned Idx = 0; 2767#define LANGOPT(Name, Bits, Default, Description) \ 2768 LangOpts.Name = Record[Idx++]; 2769#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \ 2770 LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++])); 2771#include "clang/Basic/LangOptions.def" 2772 2773 return Listener->ReadLanguageOptions(LangOpts); 2774 } 2775 2776 return false; 2777} 2778 2779PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) { 2780 PreprocessedEntityID PPID = Index+1; 2781 GlobalPreprocessedEntityMapType::iterator 2782 I = GlobalPreprocessedEntityMap.find(Index); 2783 assert(I != GlobalPreprocessedEntityMap.end() && 2784 "Corrupted global preprocessed entity map"); 2785 Module &M = *I->second; 2786 unsigned LocalIndex = Index - M.BasePreprocessedEntityID; 2787 const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex]; 2788 2789 SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor); 2790 M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset); 2791 2792 unsigned Code = M.PreprocessorDetailCursor.ReadCode(); 2793 switch (Code) { 2794 case llvm::bitc::END_BLOCK: 2795 return 0; 2796 2797 case llvm::bitc::ENTER_SUBBLOCK: 2798 Error("unexpected subblock record in preprocessor detail block"); 2799 return 0; 2800 2801 case llvm::bitc::DEFINE_ABBREV: 2802 Error("unexpected abbrevation record in preprocessor detail block"); 2803 return 0; 2804 2805 default: 2806 break; 2807 } 2808 2809 if (!PP.getPreprocessingRecord()) { 2810 Error("no preprocessing record"); 2811 return 0; 2812 } 2813 2814 // Read the record. 2815 SourceRange Range(ReadSourceLocation(M, PPOffs.Begin), 2816 ReadSourceLocation(M, PPOffs.End)); 2817 PreprocessingRecord &PPRec = *PP.getPreprocessingRecord(); 2818 const char *BlobStart = 0; 2819 unsigned BlobLen = 0; 2820 RecordData Record; 2821 PreprocessorDetailRecordTypes RecType = 2822 (PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.ReadRecord( 2823 Code, Record, BlobStart, BlobLen); 2824 switch (RecType) { 2825 case PPD_MACRO_EXPANSION: { 2826 bool isBuiltin = Record[0]; 2827 IdentifierInfo *Name = 0; 2828 MacroDefinition *Def = 0; 2829 if (isBuiltin) 2830 Name = getLocalIdentifier(M, Record[1]); 2831 else { 2832 PreprocessedEntityID 2833 GlobalID = getGlobalPreprocessedEntityID(M, Record[1]); 2834 Def =cast<MacroDefinition>(PPRec.getLoadedPreprocessedEntity(GlobalID-1)); 2835 } 2836 2837 MacroExpansion *ME; 2838 if (isBuiltin) 2839 ME = new (PPRec) MacroExpansion(Name, Range); 2840 else 2841 ME = new (PPRec) MacroExpansion(Def, Range); 2842 2843 return ME; 2844 } 2845 2846 case PPD_MACRO_DEFINITION: { 2847 // Decode the identifier info and then check again; if the macro is 2848 // still defined and associated with the identifier, 2849 IdentifierInfo *II = getLocalIdentifier(M, Record[0]); 2850 MacroDefinition *MD 2851 = new (PPRec) MacroDefinition(II, Range); 2852 2853 if (DeserializationListener) 2854 DeserializationListener->MacroDefinitionRead(PPID, MD); 2855 2856 return MD; 2857 } 2858 2859 case PPD_INCLUSION_DIRECTIVE: { 2860 const char *FullFileNameStart = BlobStart + Record[0]; 2861 const FileEntry *File 2862 = PP.getFileManager().getFile(StringRef(FullFileNameStart, 2863 BlobLen - Record[0])); 2864 2865 // FIXME: Stable encoding 2866 InclusionDirective::InclusionKind Kind 2867 = static_cast<InclusionDirective::InclusionKind>(Record[2]); 2868 InclusionDirective *ID 2869 = new (PPRec) InclusionDirective(PPRec, Kind, 2870 StringRef(BlobStart, Record[0]), 2871 Record[1], 2872 File, 2873 Range); 2874 return ID; 2875 } 2876 } 2877 2878 Error("invalid offset in preprocessor detail block"); 2879 return 0; 2880} 2881 2882/// \brief \arg SLocMapI points at a chunk of a module that contains no 2883/// preprocessed entities or the entities it contains are not the ones we are 2884/// looking for. Find the next module that contains entities and return the ID 2885/// of the first entry. 2886PreprocessedEntityID ASTReader::findNextPreprocessedEntity( 2887 GlobalSLocOffsetMapType::const_iterator SLocMapI) const { 2888 ++SLocMapI; 2889 for (GlobalSLocOffsetMapType::const_iterator 2890 EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) { 2891 Module &M = *SLocMapI->second; 2892 if (M.NumPreprocessedEntities) 2893 return getGlobalPreprocessedEntityID(M, M.BasePreprocessedEntityID); 2894 } 2895 2896 return getTotalNumPreprocessedEntities(); 2897} 2898 2899namespace { 2900 2901template <unsigned PPEntityOffset::*PPLoc> 2902struct PPEntityComp { 2903 const ASTReader &Reader; 2904 Module &M; 2905 2906 PPEntityComp(const ASTReader &Reader, Module &M) : Reader(Reader), M(M) { } 2907 2908 bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const { 2909 SourceLocation LHS = getLoc(L); 2910 SourceLocation RHS = getLoc(R); 2911 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 2912 } 2913 2914 bool operator()(const PPEntityOffset &L, SourceLocation RHS) const { 2915 SourceLocation LHS = getLoc(L); 2916 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 2917 } 2918 2919 bool operator()(SourceLocation LHS, const PPEntityOffset &R) const { 2920 SourceLocation RHS = getLoc(R); 2921 return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS); 2922 } 2923 2924 SourceLocation getLoc(const PPEntityOffset &PPE) const { 2925 return Reader.ReadSourceLocation(M, PPE.*PPLoc); 2926 } 2927}; 2928 2929} 2930 2931/// \brief Returns the first preprocessed entity ID that ends after \arg BLoc. 2932PreprocessedEntityID 2933ASTReader::findBeginPreprocessedEntity(SourceLocation BLoc) const { 2934 if (SourceMgr.isLocalSourceLocation(BLoc)) 2935 return getTotalNumPreprocessedEntities(); 2936 2937 GlobalSLocOffsetMapType::const_iterator 2938 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 2939 BLoc.getOffset()); 2940 assert(SLocMapI != GlobalSLocOffsetMap.end() && 2941 "Corrupted global sloc offset map"); 2942 2943 if (SLocMapI->second->NumPreprocessedEntities == 0) 2944 return findNextPreprocessedEntity(SLocMapI); 2945 2946 Module &M = *SLocMapI->second; 2947 typedef const PPEntityOffset *pp_iterator; 2948 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 2949 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 2950 2951 size_t Count = M.NumPreprocessedEntities; 2952 size_t Half; 2953 pp_iterator First = pp_begin; 2954 pp_iterator PPI; 2955 2956 // Do a binary search manually instead of using std::lower_bound because 2957 // The end locations of entities may be unordered (when a macro expansion 2958 // is inside another macro argument), but for this case it is not important 2959 // whether we get the first macro expansion or its containing macro. 2960 while (Count > 0) { 2961 Half = Count/2; 2962 PPI = First; 2963 std::advance(PPI, Half); 2964 if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End), 2965 BLoc)){ 2966 First = PPI; 2967 ++First; 2968 Count = Count - Half - 1; 2969 } else 2970 Count = Half; 2971 } 2972 2973 if (PPI == pp_end) 2974 return findNextPreprocessedEntity(SLocMapI); 2975 2976 return getGlobalPreprocessedEntityID(M, 2977 M.BasePreprocessedEntityID + (PPI - pp_begin)); 2978} 2979 2980/// \brief Returns the first preprocessed entity ID that begins after \arg ELoc. 2981PreprocessedEntityID 2982ASTReader::findEndPreprocessedEntity(SourceLocation ELoc) const { 2983 if (SourceMgr.isLocalSourceLocation(ELoc)) 2984 return getTotalNumPreprocessedEntities(); 2985 2986 GlobalSLocOffsetMapType::const_iterator 2987 SLocMapI = GlobalSLocOffsetMap.find(SourceManager::MaxLoadedOffset - 2988 ELoc.getOffset()); 2989 assert(SLocMapI != GlobalSLocOffsetMap.end() && 2990 "Corrupted global sloc offset map"); 2991 2992 if (SLocMapI->second->NumPreprocessedEntities == 0) 2993 return findNextPreprocessedEntity(SLocMapI); 2994 2995 Module &M = *SLocMapI->second; 2996 typedef const PPEntityOffset *pp_iterator; 2997 pp_iterator pp_begin = M.PreprocessedEntityOffsets; 2998 pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities; 2999 pp_iterator PPI = 3000 std::upper_bound(pp_begin, pp_end, ELoc, 3001 PPEntityComp<&PPEntityOffset::Begin>(*this, M)); 3002 3003 if (PPI == pp_end) 3004 return findNextPreprocessedEntity(SLocMapI); 3005 3006 return getGlobalPreprocessedEntityID(M, 3007 M.BasePreprocessedEntityID + (PPI - pp_begin)); 3008} 3009 3010/// \brief Returns a pair of [Begin, End) indices of preallocated 3011/// preprocessed entities that \arg Range encompasses. 3012std::pair<unsigned, unsigned> 3013 ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) { 3014 if (Range.isInvalid()) 3015 return std::make_pair(0,0); 3016 assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin())); 3017 3018 PreprocessedEntityID BeginID = findBeginPreprocessedEntity(Range.getBegin()); 3019 PreprocessedEntityID EndID = findEndPreprocessedEntity(Range.getEnd()); 3020 return std::make_pair(BeginID, EndID); 3021} 3022 3023namespace { 3024 /// \brief Visitor used to search for information about a header file. 3025 class HeaderFileInfoVisitor { 3026 ASTReader &Reader; 3027 const FileEntry *FE; 3028 3029 llvm::Optional<HeaderFileInfo> HFI; 3030 3031 public: 3032 HeaderFileInfoVisitor(ASTReader &Reader, const FileEntry *FE) 3033 : Reader(Reader), FE(FE) { } 3034 3035 static bool visit(Module &M, void *UserData) { 3036 HeaderFileInfoVisitor *This 3037 = static_cast<HeaderFileInfoVisitor *>(UserData); 3038 3039 HeaderFileInfoTrait Trait(This->Reader, M, 3040 &This->Reader.getPreprocessor().getHeaderSearchInfo(), 3041 M.HeaderFileFrameworkStrings, 3042 This->FE->getName()); 3043 3044 HeaderFileInfoLookupTable *Table 3045 = static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable); 3046 if (!Table) 3047 return false; 3048 3049 // Look in the on-disk hash table for an entry for this file name. 3050 HeaderFileInfoLookupTable::iterator Pos = Table->find(This->FE->getName(), 3051 &Trait); 3052 if (Pos == Table->end()) 3053 return false; 3054 3055 This->HFI = *Pos; 3056 return true; 3057 } 3058 3059 llvm::Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; } 3060 }; 3061} 3062 3063HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) { 3064 HeaderFileInfoVisitor Visitor(*this, FE); 3065 ModuleMgr.visit(&HeaderFileInfoVisitor::visit, &Visitor); 3066 if (llvm::Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo()) { 3067 if (Listener) 3068 Listener->ReadHeaderFileInfo(*HFI, FE->getUID()); 3069 return *HFI; 3070 } 3071 3072 return HeaderFileInfo(); 3073} 3074 3075void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) { 3076 for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) { 3077 Module &F = *(*I); 3078 unsigned Idx = 0; 3079 while (Idx < F.PragmaDiagMappings.size()) { 3080 SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]); 3081 while (1) { 3082 assert(Idx < F.PragmaDiagMappings.size() && 3083 "Invalid data, didn't find '-1' marking end of diag/map pairs"); 3084 if (Idx >= F.PragmaDiagMappings.size()) { 3085 break; // Something is messed up but at least avoid infinite loop in 3086 // release build. 3087 } 3088 unsigned DiagID = F.PragmaDiagMappings[Idx++]; 3089 if (DiagID == (unsigned)-1) { 3090 break; // no more diag/map pairs for this location. 3091 } 3092 diag::Mapping Map = (diag::Mapping)F.PragmaDiagMappings[Idx++]; 3093 // The user bit gets set by WritePragmaDiagnosticMappings. 3094 Diag.setDiagnosticMapping(DiagID, Map, Loc); 3095 } 3096 } 3097 } 3098} 3099 3100/// \brief Get the correct cursor and offset for loading a type. 3101ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) { 3102 GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index); 3103 assert(I != GlobalTypeMap.end() && "Corrupted global type map"); 3104 Module *M = I->second; 3105 return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]); 3106} 3107 3108/// \brief Read and return the type with the given index.. 3109/// 3110/// The index is the type ID, shifted and minus the number of predefs. This 3111/// routine actually reads the record corresponding to the type at the given 3112/// location. It is a helper routine for GetType, which deals with reading type 3113/// IDs. 3114QualType ASTReader::readTypeRecord(unsigned Index) { 3115 RecordLocation Loc = TypeCursorForIndex(Index); 3116 llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor; 3117 3118 // Keep track of where we are in the stream, then jump back there 3119 // after reading this type. 3120 SavedStreamPosition SavedPosition(DeclsCursor); 3121 3122 ReadingKindTracker ReadingKind(Read_Type, *this); 3123 3124 // Note that we are loading a type record. 3125 Deserializing AType(this); 3126 3127 unsigned Idx = 0; 3128 DeclsCursor.JumpToBit(Loc.Offset); 3129 RecordData Record; 3130 unsigned Code = DeclsCursor.ReadCode(); 3131 switch ((TypeCode)DeclsCursor.ReadRecord(Code, Record)) { 3132 case TYPE_EXT_QUAL: { 3133 if (Record.size() != 2) { 3134 Error("Incorrect encoding of extended qualifier type"); 3135 return QualType(); 3136 } 3137 QualType Base = readType(*Loc.F, Record, Idx); 3138 Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]); 3139 return Context.getQualifiedType(Base, Quals); 3140 } 3141 3142 case TYPE_COMPLEX: { 3143 if (Record.size() != 1) { 3144 Error("Incorrect encoding of complex type"); 3145 return QualType(); 3146 } 3147 QualType ElemType = readType(*Loc.F, Record, Idx); 3148 return Context.getComplexType(ElemType); 3149 } 3150 3151 case TYPE_POINTER: { 3152 if (Record.size() != 1) { 3153 Error("Incorrect encoding of pointer type"); 3154 return QualType(); 3155 } 3156 QualType PointeeType = readType(*Loc.F, Record, Idx); 3157 return Context.getPointerType(PointeeType); 3158 } 3159 3160 case TYPE_BLOCK_POINTER: { 3161 if (Record.size() != 1) { 3162 Error("Incorrect encoding of block pointer type"); 3163 return QualType(); 3164 } 3165 QualType PointeeType = readType(*Loc.F, Record, Idx); 3166 return Context.getBlockPointerType(PointeeType); 3167 } 3168 3169 case TYPE_LVALUE_REFERENCE: { 3170 if (Record.size() != 2) { 3171 Error("Incorrect encoding of lvalue reference type"); 3172 return QualType(); 3173 } 3174 QualType PointeeType = readType(*Loc.F, Record, Idx); 3175 return Context.getLValueReferenceType(PointeeType, Record[1]); 3176 } 3177 3178 case TYPE_RVALUE_REFERENCE: { 3179 if (Record.size() != 1) { 3180 Error("Incorrect encoding of rvalue reference type"); 3181 return QualType(); 3182 } 3183 QualType PointeeType = readType(*Loc.F, Record, Idx); 3184 return Context.getRValueReferenceType(PointeeType); 3185 } 3186 3187 case TYPE_MEMBER_POINTER: { 3188 if (Record.size() != 2) { 3189 Error("Incorrect encoding of member pointer type"); 3190 return QualType(); 3191 } 3192 QualType PointeeType = readType(*Loc.F, Record, Idx); 3193 QualType ClassType = readType(*Loc.F, Record, Idx); 3194 if (PointeeType.isNull() || ClassType.isNull()) 3195 return QualType(); 3196 3197 return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr()); 3198 } 3199 3200 case TYPE_CONSTANT_ARRAY: { 3201 QualType ElementType = readType(*Loc.F, Record, Idx); 3202 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3203 unsigned IndexTypeQuals = Record[2]; 3204 unsigned Idx = 3; 3205 llvm::APInt Size = ReadAPInt(Record, Idx); 3206 return Context.getConstantArrayType(ElementType, Size, 3207 ASM, IndexTypeQuals); 3208 } 3209 3210 case TYPE_INCOMPLETE_ARRAY: { 3211 QualType ElementType = readType(*Loc.F, Record, Idx); 3212 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3213 unsigned IndexTypeQuals = Record[2]; 3214 return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals); 3215 } 3216 3217 case TYPE_VARIABLE_ARRAY: { 3218 QualType ElementType = readType(*Loc.F, Record, Idx); 3219 ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1]; 3220 unsigned IndexTypeQuals = Record[2]; 3221 SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]); 3222 SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]); 3223 return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F), 3224 ASM, IndexTypeQuals, 3225 SourceRange(LBLoc, RBLoc)); 3226 } 3227 3228 case TYPE_VECTOR: { 3229 if (Record.size() != 3) { 3230 Error("incorrect encoding of vector type in AST file"); 3231 return QualType(); 3232 } 3233 3234 QualType ElementType = readType(*Loc.F, Record, Idx); 3235 unsigned NumElements = Record[1]; 3236 unsigned VecKind = Record[2]; 3237 return Context.getVectorType(ElementType, NumElements, 3238 (VectorType::VectorKind)VecKind); 3239 } 3240 3241 case TYPE_EXT_VECTOR: { 3242 if (Record.size() != 3) { 3243 Error("incorrect encoding of extended vector type in AST file"); 3244 return QualType(); 3245 } 3246 3247 QualType ElementType = readType(*Loc.F, Record, Idx); 3248 unsigned NumElements = Record[1]; 3249 return Context.getExtVectorType(ElementType, NumElements); 3250 } 3251 3252 case TYPE_FUNCTION_NO_PROTO: { 3253 if (Record.size() != 6) { 3254 Error("incorrect encoding of no-proto function type"); 3255 return QualType(); 3256 } 3257 QualType ResultType = readType(*Loc.F, Record, Idx); 3258 FunctionType::ExtInfo Info(Record[1], Record[2], Record[3], 3259 (CallingConv)Record[4], Record[5]); 3260 return Context.getFunctionNoProtoType(ResultType, Info); 3261 } 3262 3263 case TYPE_FUNCTION_PROTO: { 3264 QualType ResultType = readType(*Loc.F, Record, Idx); 3265 3266 FunctionProtoType::ExtProtoInfo EPI; 3267 EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1], 3268 /*hasregparm*/ Record[2], 3269 /*regparm*/ Record[3], 3270 static_cast<CallingConv>(Record[4]), 3271 /*produces*/ Record[5]); 3272 3273 unsigned Idx = 6; 3274 unsigned NumParams = Record[Idx++]; 3275 SmallVector<QualType, 16> ParamTypes; 3276 for (unsigned I = 0; I != NumParams; ++I) 3277 ParamTypes.push_back(readType(*Loc.F, Record, Idx)); 3278 3279 EPI.Variadic = Record[Idx++]; 3280 EPI.TypeQuals = Record[Idx++]; 3281 EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]); 3282 ExceptionSpecificationType EST = 3283 static_cast<ExceptionSpecificationType>(Record[Idx++]); 3284 EPI.ExceptionSpecType = EST; 3285 if (EST == EST_Dynamic) { 3286 EPI.NumExceptions = Record[Idx++]; 3287 SmallVector<QualType, 2> Exceptions; 3288 for (unsigned I = 0; I != EPI.NumExceptions; ++I) 3289 Exceptions.push_back(readType(*Loc.F, Record, Idx)); 3290 EPI.Exceptions = Exceptions.data(); 3291 } else if (EST == EST_ComputedNoexcept) { 3292 EPI.NoexceptExpr = ReadExpr(*Loc.F); 3293 } 3294 return Context.getFunctionType(ResultType, ParamTypes.data(), NumParams, 3295 EPI); 3296 } 3297 3298 case TYPE_UNRESOLVED_USING: { 3299 unsigned Idx = 0; 3300 return Context.getTypeDeclType( 3301 ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx)); 3302 } 3303 3304 case TYPE_TYPEDEF: { 3305 if (Record.size() != 2) { 3306 Error("incorrect encoding of typedef type"); 3307 return QualType(); 3308 } 3309 unsigned Idx = 0; 3310 TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx); 3311 QualType Canonical = readType(*Loc.F, Record, Idx); 3312 if (!Canonical.isNull()) 3313 Canonical = Context.getCanonicalType(Canonical); 3314 return Context.getTypedefType(Decl, Canonical); 3315 } 3316 3317 case TYPE_TYPEOF_EXPR: 3318 return Context.getTypeOfExprType(ReadExpr(*Loc.F)); 3319 3320 case TYPE_TYPEOF: { 3321 if (Record.size() != 1) { 3322 Error("incorrect encoding of typeof(type) in AST file"); 3323 return QualType(); 3324 } 3325 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3326 return Context.getTypeOfType(UnderlyingType); 3327 } 3328 3329 case TYPE_DECLTYPE: 3330 return Context.getDecltypeType(ReadExpr(*Loc.F)); 3331 3332 case TYPE_UNARY_TRANSFORM: { 3333 QualType BaseType = readType(*Loc.F, Record, Idx); 3334 QualType UnderlyingType = readType(*Loc.F, Record, Idx); 3335 UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2]; 3336 return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind); 3337 } 3338 3339 case TYPE_AUTO: 3340 return Context.getAutoType(readType(*Loc.F, Record, Idx)); 3341 3342 case TYPE_RECORD: { 3343 if (Record.size() != 2) { 3344 Error("incorrect encoding of record type"); 3345 return QualType(); 3346 } 3347 unsigned Idx = 0; 3348 bool IsDependent = Record[Idx++]; 3349 QualType T 3350 = Context.getRecordType(ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx)); 3351 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3352 return T; 3353 } 3354 3355 case TYPE_ENUM: { 3356 if (Record.size() != 2) { 3357 Error("incorrect encoding of enum type"); 3358 return QualType(); 3359 } 3360 unsigned Idx = 0; 3361 bool IsDependent = Record[Idx++]; 3362 QualType T 3363 = Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx)); 3364 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3365 return T; 3366 } 3367 3368 case TYPE_ATTRIBUTED: { 3369 if (Record.size() != 3) { 3370 Error("incorrect encoding of attributed type"); 3371 return QualType(); 3372 } 3373 QualType modifiedType = readType(*Loc.F, Record, Idx); 3374 QualType equivalentType = readType(*Loc.F, Record, Idx); 3375 AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]); 3376 return Context.getAttributedType(kind, modifiedType, equivalentType); 3377 } 3378 3379 case TYPE_PAREN: { 3380 if (Record.size() != 1) { 3381 Error("incorrect encoding of paren type"); 3382 return QualType(); 3383 } 3384 QualType InnerType = readType(*Loc.F, Record, Idx); 3385 return Context.getParenType(InnerType); 3386 } 3387 3388 case TYPE_PACK_EXPANSION: { 3389 if (Record.size() != 2) { 3390 Error("incorrect encoding of pack expansion type"); 3391 return QualType(); 3392 } 3393 QualType Pattern = readType(*Loc.F, Record, Idx); 3394 if (Pattern.isNull()) 3395 return QualType(); 3396 llvm::Optional<unsigned> NumExpansions; 3397 if (Record[1]) 3398 NumExpansions = Record[1] - 1; 3399 return Context.getPackExpansionType(Pattern, NumExpansions); 3400 } 3401 3402 case TYPE_ELABORATED: { 3403 unsigned Idx = 0; 3404 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3405 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3406 QualType NamedType = readType(*Loc.F, Record, Idx); 3407 return Context.getElaboratedType(Keyword, NNS, NamedType); 3408 } 3409 3410 case TYPE_OBJC_INTERFACE: { 3411 unsigned Idx = 0; 3412 ObjCInterfaceDecl *ItfD 3413 = ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx); 3414 return Context.getObjCInterfaceType(ItfD); 3415 } 3416 3417 case TYPE_OBJC_OBJECT: { 3418 unsigned Idx = 0; 3419 QualType Base = readType(*Loc.F, Record, Idx); 3420 unsigned NumProtos = Record[Idx++]; 3421 SmallVector<ObjCProtocolDecl*, 4> Protos; 3422 for (unsigned I = 0; I != NumProtos; ++I) 3423 Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx)); 3424 return Context.getObjCObjectType(Base, Protos.data(), NumProtos); 3425 } 3426 3427 case TYPE_OBJC_OBJECT_POINTER: { 3428 unsigned Idx = 0; 3429 QualType Pointee = readType(*Loc.F, Record, Idx); 3430 return Context.getObjCObjectPointerType(Pointee); 3431 } 3432 3433 case TYPE_SUBST_TEMPLATE_TYPE_PARM: { 3434 unsigned Idx = 0; 3435 QualType Parm = readType(*Loc.F, Record, Idx); 3436 QualType Replacement = readType(*Loc.F, Record, Idx); 3437 return 3438 Context.getSubstTemplateTypeParmType(cast<TemplateTypeParmType>(Parm), 3439 Replacement); 3440 } 3441 3442 case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: { 3443 unsigned Idx = 0; 3444 QualType Parm = readType(*Loc.F, Record, Idx); 3445 TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx); 3446 return Context.getSubstTemplateTypeParmPackType( 3447 cast<TemplateTypeParmType>(Parm), 3448 ArgPack); 3449 } 3450 3451 case TYPE_INJECTED_CLASS_NAME: { 3452 CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx); 3453 QualType TST = readType(*Loc.F, Record, Idx); // probably derivable 3454 // FIXME: ASTContext::getInjectedClassNameType is not currently suitable 3455 // for AST reading, too much interdependencies. 3456 return 3457 QualType(new (Context, TypeAlignment) InjectedClassNameType(D, TST), 0); 3458 } 3459 3460 case TYPE_TEMPLATE_TYPE_PARM: { 3461 unsigned Idx = 0; 3462 unsigned Depth = Record[Idx++]; 3463 unsigned Index = Record[Idx++]; 3464 bool Pack = Record[Idx++]; 3465 TemplateTypeParmDecl *D 3466 = ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx); 3467 return Context.getTemplateTypeParmType(Depth, Index, Pack, D); 3468 } 3469 3470 case TYPE_DEPENDENT_NAME: { 3471 unsigned Idx = 0; 3472 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3473 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3474 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3475 QualType Canon = readType(*Loc.F, Record, Idx); 3476 if (!Canon.isNull()) 3477 Canon = Context.getCanonicalType(Canon); 3478 return Context.getDependentNameType(Keyword, NNS, Name, Canon); 3479 } 3480 3481 case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: { 3482 unsigned Idx = 0; 3483 ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++]; 3484 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx); 3485 const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx); 3486 unsigned NumArgs = Record[Idx++]; 3487 SmallVector<TemplateArgument, 8> Args; 3488 Args.reserve(NumArgs); 3489 while (NumArgs--) 3490 Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx)); 3491 return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name, 3492 Args.size(), Args.data()); 3493 } 3494 3495 case TYPE_DEPENDENT_SIZED_ARRAY: { 3496 unsigned Idx = 0; 3497 3498 // ArrayType 3499 QualType ElementType = readType(*Loc.F, Record, Idx); 3500 ArrayType::ArraySizeModifier ASM 3501 = (ArrayType::ArraySizeModifier)Record[Idx++]; 3502 unsigned IndexTypeQuals = Record[Idx++]; 3503 3504 // DependentSizedArrayType 3505 Expr *NumElts = ReadExpr(*Loc.F); 3506 SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx); 3507 3508 return Context.getDependentSizedArrayType(ElementType, NumElts, ASM, 3509 IndexTypeQuals, Brackets); 3510 } 3511 3512 case TYPE_TEMPLATE_SPECIALIZATION: { 3513 unsigned Idx = 0; 3514 bool IsDependent = Record[Idx++]; 3515 TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx); 3516 SmallVector<TemplateArgument, 8> Args; 3517 ReadTemplateArgumentList(Args, *Loc.F, Record, Idx); 3518 QualType Underlying = readType(*Loc.F, Record, Idx); 3519 QualType T; 3520 if (Underlying.isNull()) 3521 T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(), 3522 Args.size()); 3523 else 3524 T = Context.getTemplateSpecializationType(Name, Args.data(), 3525 Args.size(), Underlying); 3526 const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent); 3527 return T; 3528 } 3529 } 3530 // Suppress a GCC warning 3531 return QualType(); 3532} 3533 3534class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> { 3535 ASTReader &Reader; 3536 Module &F; 3537 llvm::BitstreamCursor &DeclsCursor; 3538 const ASTReader::RecordData &Record; 3539 unsigned &Idx; 3540 3541 SourceLocation ReadSourceLocation(const ASTReader::RecordData &R, 3542 unsigned &I) { 3543 return Reader.ReadSourceLocation(F, R, I); 3544 } 3545 3546 template<typename T> 3547 T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) { 3548 return Reader.ReadDeclAs<T>(F, Record, Idx); 3549 } 3550 3551public: 3552 TypeLocReader(ASTReader &Reader, Module &F, 3553 const ASTReader::RecordData &Record, unsigned &Idx) 3554 : Reader(Reader), F(F), DeclsCursor(F.DeclsCursor), Record(Record), Idx(Idx) 3555 { } 3556 3557 // We want compile-time assurance that we've enumerated all of 3558 // these, so unfortunately we have to declare them first, then 3559 // define them out-of-line. 3560#define ABSTRACT_TYPELOC(CLASS, PARENT) 3561#define TYPELOC(CLASS, PARENT) \ 3562 void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc); 3563#include "clang/AST/TypeLocNodes.def" 3564 3565 void VisitFunctionTypeLoc(FunctionTypeLoc); 3566 void VisitArrayTypeLoc(ArrayTypeLoc); 3567}; 3568 3569void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 3570 // nothing to do 3571} 3572void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 3573 TL.setBuiltinLoc(ReadSourceLocation(Record, Idx)); 3574 if (TL.needsExtraLocalData()) { 3575 TL.setWrittenTypeSpec(static_cast<DeclSpec::TST>(Record[Idx++])); 3576 TL.setWrittenSignSpec(static_cast<DeclSpec::TSS>(Record[Idx++])); 3577 TL.setWrittenWidthSpec(static_cast<DeclSpec::TSW>(Record[Idx++])); 3578 TL.setModeAttr(Record[Idx++]); 3579 } 3580} 3581void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) { 3582 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3583} 3584void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) { 3585 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3586} 3587void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 3588 TL.setCaretLoc(ReadSourceLocation(Record, Idx)); 3589} 3590void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 3591 TL.setAmpLoc(ReadSourceLocation(Record, Idx)); 3592} 3593void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 3594 TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx)); 3595} 3596void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 3597 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3598 TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3599} 3600void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) { 3601 TL.setLBracketLoc(ReadSourceLocation(Record, Idx)); 3602 TL.setRBracketLoc(ReadSourceLocation(Record, Idx)); 3603 if (Record[Idx++]) 3604 TL.setSizeExpr(Reader.ReadExpr(F)); 3605 else 3606 TL.setSizeExpr(0); 3607} 3608void TypeLocReader::VisitConstantArrayTypeLoc(ConstantArrayTypeLoc TL) { 3609 VisitArrayTypeLoc(TL); 3610} 3611void TypeLocReader::VisitIncompleteArrayTypeLoc(IncompleteArrayTypeLoc TL) { 3612 VisitArrayTypeLoc(TL); 3613} 3614void TypeLocReader::VisitVariableArrayTypeLoc(VariableArrayTypeLoc TL) { 3615 VisitArrayTypeLoc(TL); 3616} 3617void TypeLocReader::VisitDependentSizedArrayTypeLoc( 3618 DependentSizedArrayTypeLoc TL) { 3619 VisitArrayTypeLoc(TL); 3620} 3621void TypeLocReader::VisitDependentSizedExtVectorTypeLoc( 3622 DependentSizedExtVectorTypeLoc TL) { 3623 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3624} 3625void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) { 3626 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3627} 3628void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) { 3629 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3630} 3631void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) { 3632 TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx)); 3633 TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx)); 3634 TL.setTrailingReturn(Record[Idx++]); 3635 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) { 3636 TL.setArg(i, ReadDeclAs<ParmVarDecl>(Record, Idx)); 3637 } 3638} 3639void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) { 3640 VisitFunctionTypeLoc(TL); 3641} 3642void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) { 3643 VisitFunctionTypeLoc(TL); 3644} 3645void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) { 3646 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3647} 3648void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) { 3649 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3650} 3651void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 3652 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3653 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3654 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3655} 3656void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 3657 TL.setTypeofLoc(ReadSourceLocation(Record, Idx)); 3658 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3659 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3660 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3661} 3662void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) { 3663 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3664} 3665void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 3666 TL.setKWLoc(ReadSourceLocation(Record, Idx)); 3667 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3668 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3669 TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx)); 3670} 3671void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) { 3672 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3673} 3674void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) { 3675 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3676} 3677void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) { 3678 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3679} 3680void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) { 3681 TL.setAttrNameLoc(ReadSourceLocation(Record, Idx)); 3682 if (TL.hasAttrOperand()) { 3683 SourceRange range; 3684 range.setBegin(ReadSourceLocation(Record, Idx)); 3685 range.setEnd(ReadSourceLocation(Record, Idx)); 3686 TL.setAttrOperandParensRange(range); 3687 } 3688 if (TL.hasAttrExprOperand()) { 3689 if (Record[Idx++]) 3690 TL.setAttrExprOperand(Reader.ReadExpr(F)); 3691 else 3692 TL.setAttrExprOperand(0); 3693 } else if (TL.hasAttrEnumOperand()) 3694 TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx)); 3695} 3696void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) { 3697 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3698} 3699void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc( 3700 SubstTemplateTypeParmTypeLoc TL) { 3701 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3702} 3703void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc( 3704 SubstTemplateTypeParmPackTypeLoc TL) { 3705 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3706} 3707void TypeLocReader::VisitTemplateSpecializationTypeLoc( 3708 TemplateSpecializationTypeLoc TL) { 3709 TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx)); 3710 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3711 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3712 for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i) 3713 TL.setArgLocInfo(i, 3714 Reader.GetTemplateArgumentLocInfo(F, 3715 TL.getTypePtr()->getArg(i).getKind(), 3716 Record, Idx)); 3717} 3718void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) { 3719 TL.setLParenLoc(ReadSourceLocation(Record, Idx)); 3720 TL.setRParenLoc(ReadSourceLocation(Record, Idx)); 3721} 3722void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 3723 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3724 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3725} 3726void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) { 3727 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3728} 3729void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 3730 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3731 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3732 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3733} 3734void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc( 3735 DependentTemplateSpecializationTypeLoc TL) { 3736 TL.setKeywordLoc(ReadSourceLocation(Record, Idx)); 3737 TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx)); 3738 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3739 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3740 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3741 for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I) 3742 TL.setArgLocInfo(I, 3743 Reader.GetTemplateArgumentLocInfo(F, 3744 TL.getTypePtr()->getArg(I).getKind(), 3745 Record, Idx)); 3746} 3747void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) { 3748 TL.setEllipsisLoc(ReadSourceLocation(Record, Idx)); 3749} 3750void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 3751 TL.setNameLoc(ReadSourceLocation(Record, Idx)); 3752} 3753void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 3754 TL.setHasBaseTypeAsWritten(Record[Idx++]); 3755 TL.setLAngleLoc(ReadSourceLocation(Record, Idx)); 3756 TL.setRAngleLoc(ReadSourceLocation(Record, Idx)); 3757 for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) 3758 TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx)); 3759} 3760void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 3761 TL.setStarLoc(ReadSourceLocation(Record, Idx)); 3762} 3763 3764TypeSourceInfo *ASTReader::GetTypeSourceInfo(Module &F, 3765 const RecordData &Record, 3766 unsigned &Idx) { 3767 QualType InfoTy = readType(F, Record, Idx); 3768 if (InfoTy.isNull()) 3769 return 0; 3770 3771 TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy); 3772 TypeLocReader TLR(*this, F, Record, Idx); 3773 for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) 3774 TLR.Visit(TL); 3775 return TInfo; 3776} 3777 3778QualType ASTReader::GetType(TypeID ID) { 3779 unsigned FastQuals = ID & Qualifiers::FastMask; 3780 unsigned Index = ID >> Qualifiers::FastWidth; 3781 3782 if (Index < NUM_PREDEF_TYPE_IDS) { 3783 QualType T; 3784 switch ((PredefinedTypeIDs)Index) { 3785 case PREDEF_TYPE_NULL_ID: return QualType(); 3786 case PREDEF_TYPE_VOID_ID: T = Context.VoidTy; break; 3787 case PREDEF_TYPE_BOOL_ID: T = Context.BoolTy; break; 3788 3789 case PREDEF_TYPE_CHAR_U_ID: 3790 case PREDEF_TYPE_CHAR_S_ID: 3791 // FIXME: Check that the signedness of CharTy is correct! 3792 T = Context.CharTy; 3793 break; 3794 3795 case PREDEF_TYPE_UCHAR_ID: T = Context.UnsignedCharTy; break; 3796 case PREDEF_TYPE_USHORT_ID: T = Context.UnsignedShortTy; break; 3797 case PREDEF_TYPE_UINT_ID: T = Context.UnsignedIntTy; break; 3798 case PREDEF_TYPE_ULONG_ID: T = Context.UnsignedLongTy; break; 3799 case PREDEF_TYPE_ULONGLONG_ID: T = Context.UnsignedLongLongTy; break; 3800 case PREDEF_TYPE_UINT128_ID: T = Context.UnsignedInt128Ty; break; 3801 case PREDEF_TYPE_SCHAR_ID: T = Context.SignedCharTy; break; 3802 case PREDEF_TYPE_WCHAR_ID: T = Context.WCharTy; break; 3803 case PREDEF_TYPE_SHORT_ID: T = Context.ShortTy; break; 3804 case PREDEF_TYPE_INT_ID: T = Context.IntTy; break; 3805 case PREDEF_TYPE_LONG_ID: T = Context.LongTy; break; 3806 case PREDEF_TYPE_LONGLONG_ID: T = Context.LongLongTy; break; 3807 case PREDEF_TYPE_INT128_ID: T = Context.Int128Ty; break; 3808 case PREDEF_TYPE_FLOAT_ID: T = Context.FloatTy; break; 3809 case PREDEF_TYPE_DOUBLE_ID: T = Context.DoubleTy; break; 3810 case PREDEF_TYPE_LONGDOUBLE_ID: T = Context.LongDoubleTy; break; 3811 case PREDEF_TYPE_OVERLOAD_ID: T = Context.OverloadTy; break; 3812 case PREDEF_TYPE_BOUND_MEMBER: T = Context.BoundMemberTy; break; 3813 case PREDEF_TYPE_DEPENDENT_ID: T = Context.DependentTy; break; 3814 case PREDEF_TYPE_UNKNOWN_ANY: T = Context.UnknownAnyTy; break; 3815 case PREDEF_TYPE_NULLPTR_ID: T = Context.NullPtrTy; break; 3816 case PREDEF_TYPE_CHAR16_ID: T = Context.Char16Ty; break; 3817 case PREDEF_TYPE_CHAR32_ID: T = Context.Char32Ty; break; 3818 case PREDEF_TYPE_OBJC_ID: T = Context.ObjCBuiltinIdTy; break; 3819 case PREDEF_TYPE_OBJC_CLASS: T = Context.ObjCBuiltinClassTy; break; 3820 case PREDEF_TYPE_OBJC_SEL: T = Context.ObjCBuiltinSelTy; break; 3821 case PREDEF_TYPE_AUTO_DEDUCT: T = Context.getAutoDeductType(); break; 3822 3823 case PREDEF_TYPE_AUTO_RREF_DEDUCT: 3824 T = Context.getAutoRRefDeductType(); 3825 break; 3826 } 3827 3828 assert(!T.isNull() && "Unknown predefined type"); 3829 return T.withFastQualifiers(FastQuals); 3830 } 3831 3832 Index -= NUM_PREDEF_TYPE_IDS; 3833 assert(Index < TypesLoaded.size() && "Type index out-of-range"); 3834 if (TypesLoaded[Index].isNull()) { 3835 TypesLoaded[Index] = readTypeRecord(Index); 3836 if (TypesLoaded[Index].isNull()) 3837 return QualType(); 3838 3839 TypesLoaded[Index]->setFromAST(); 3840 if (DeserializationListener) 3841 DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID), 3842 TypesLoaded[Index]); 3843 } 3844 3845 return TypesLoaded[Index].withFastQualifiers(FastQuals); 3846} 3847 3848QualType ASTReader::getLocalType(Module &F, unsigned LocalID) { 3849 return GetType(getGlobalTypeID(F, LocalID)); 3850} 3851 3852serialization::TypeID 3853ASTReader::getGlobalTypeID(Module &F, unsigned LocalID) const { 3854 unsigned FastQuals = LocalID & Qualifiers::FastMask; 3855 unsigned LocalIndex = LocalID >> Qualifiers::FastWidth; 3856 3857 if (LocalIndex < NUM_PREDEF_TYPE_IDS) 3858 return LocalID; 3859 3860 ContinuousRangeMap<uint32_t, int, 2>::iterator I 3861 = F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS); 3862 assert(I != F.TypeRemap.end() && "Invalid index into type index remap"); 3863 3864 unsigned GlobalIndex = LocalIndex + I->second; 3865 return (GlobalIndex << Qualifiers::FastWidth) | FastQuals; 3866} 3867 3868TemplateArgumentLocInfo 3869ASTReader::GetTemplateArgumentLocInfo(Module &F, 3870 TemplateArgument::ArgKind Kind, 3871 const RecordData &Record, 3872 unsigned &Index) { 3873 switch (Kind) { 3874 case TemplateArgument::Expression: 3875 return ReadExpr(F); 3876 case TemplateArgument::Type: 3877 return GetTypeSourceInfo(F, Record, Index); 3878 case TemplateArgument::Template: { 3879 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3880 Index); 3881 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3882 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3883 SourceLocation()); 3884 } 3885 case TemplateArgument::TemplateExpansion: { 3886 NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, 3887 Index); 3888 SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index); 3889 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index); 3890 return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc, 3891 EllipsisLoc); 3892 } 3893 case TemplateArgument::Null: 3894 case TemplateArgument::Integral: 3895 case TemplateArgument::Declaration: 3896 case TemplateArgument::Pack: 3897 return TemplateArgumentLocInfo(); 3898 } 3899 llvm_unreachable("unexpected template argument loc"); 3900 return TemplateArgumentLocInfo(); 3901} 3902 3903TemplateArgumentLoc 3904ASTReader::ReadTemplateArgumentLoc(Module &F, 3905 const RecordData &Record, unsigned &Index) { 3906 TemplateArgument Arg = ReadTemplateArgument(F, Record, Index); 3907 3908 if (Arg.getKind() == TemplateArgument::Expression) { 3909 if (Record[Index++]) // bool InfoHasSameExpr. 3910 return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr())); 3911 } 3912 return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(), 3913 Record, Index)); 3914} 3915 3916Decl *ASTReader::GetExternalDecl(uint32_t ID) { 3917 return GetDecl(ID); 3918} 3919 3920uint64_t ASTReader::readCXXBaseSpecifiers(Module &M, const RecordData &Record, 3921 unsigned &Idx){ 3922 if (Idx >= Record.size()) 3923 return 0; 3924 3925 unsigned LocalID = Record[Idx++]; 3926 return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]); 3927} 3928 3929CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 3930 RecordLocation Loc = getLocalBitOffset(Offset); 3931 llvm::BitstreamCursor &Cursor = Loc.F->DeclsCursor; 3932 SavedStreamPosition SavedPosition(Cursor); 3933 Cursor.JumpToBit(Loc.Offset); 3934 ReadingKindTracker ReadingKind(Read_Decl, *this); 3935 RecordData Record; 3936 unsigned Code = Cursor.ReadCode(); 3937 unsigned RecCode = Cursor.ReadRecord(Code, Record); 3938 if (RecCode != DECL_CXX_BASE_SPECIFIERS) { 3939 Error("Malformed AST file: missing C++ base specifiers"); 3940 return 0; 3941 } 3942 3943 unsigned Idx = 0; 3944 unsigned NumBases = Record[Idx++]; 3945 void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases); 3946 CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases]; 3947 for (unsigned I = 0; I != NumBases; ++I) 3948 Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx); 3949 return Bases; 3950} 3951 3952serialization::DeclID 3953ASTReader::getGlobalDeclID(Module &F, unsigned LocalID) const { 3954 if (LocalID < NUM_PREDEF_DECL_IDS) 3955 return LocalID; 3956 3957 ContinuousRangeMap<uint32_t, int, 2>::iterator I 3958 = F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS); 3959 assert(I != F.DeclRemap.end() && "Invalid index into decl index remap"); 3960 3961 return LocalID + I->second; 3962} 3963 3964bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID, 3965 Module &M) const { 3966 GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(ID); 3967 assert(I != GlobalDeclMap.end() && "Corrupted global declaration map"); 3968 return &M == I->second; 3969} 3970 3971Decl *ASTReader::GetDecl(DeclID ID) { 3972 if (ID < NUM_PREDEF_DECL_IDS) { 3973 switch ((PredefinedDeclIDs)ID) { 3974 case PREDEF_DECL_NULL_ID: 3975 return 0; 3976 3977 case PREDEF_DECL_TRANSLATION_UNIT_ID: 3978 return Context.getTranslationUnitDecl(); 3979 3980 case PREDEF_DECL_OBJC_ID_ID: 3981 return Context.getObjCIdDecl(); 3982 3983 case PREDEF_DECL_OBJC_SEL_ID: 3984 return Context.getObjCSelDecl(); 3985 3986 case PREDEF_DECL_OBJC_CLASS_ID: 3987 return Context.getObjCClassDecl(); 3988 3989 case PREDEF_DECL_INT_128_ID: 3990 return Context.getInt128Decl(); 3991 3992 case PREDEF_DECL_UNSIGNED_INT_128_ID: 3993 return Context.getUInt128Decl(); 3994 3995 case PREDEF_DECL_OBJC_INSTANCETYPE_ID: 3996 return Context.getObjCInstanceTypeDecl(); 3997 } 3998 3999 return 0; 4000 } 4001 4002 unsigned Index = ID - NUM_PREDEF_DECL_IDS; 4003 4004 if (Index > DeclsLoaded.size()) { 4005 Error("declaration ID out-of-range for AST file"); 4006 return 0; 4007 } 4008 4009if (!DeclsLoaded[Index]) { 4010 ReadDeclRecord(ID); 4011 if (DeserializationListener) 4012 DeserializationListener->DeclRead(ID, DeclsLoaded[Index]); 4013 } 4014 4015 return DeclsLoaded[Index]; 4016} 4017 4018serialization::DeclID ASTReader::ReadDeclID(Module &F, 4019 const RecordData &Record, 4020 unsigned &Idx) { 4021 if (Idx >= Record.size()) { 4022 Error("Corrupted AST file"); 4023 return 0; 4024 } 4025 4026 return getGlobalDeclID(F, Record[Idx++]); 4027} 4028 4029/// \brief Resolve the offset of a statement into a statement. 4030/// 4031/// This operation will read a new statement from the external 4032/// source each time it is called, and is meant to be used via a 4033/// LazyOffsetPtr (which is used by Decls for the body of functions, etc). 4034Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) { 4035 // Switch case IDs are per Decl. 4036 ClearSwitchCaseIDs(); 4037 4038 // Offset here is a global offset across the entire chain. 4039 RecordLocation Loc = getLocalBitOffset(Offset); 4040 Loc.F->DeclsCursor.JumpToBit(Loc.Offset); 4041 return ReadStmtFromStream(*Loc.F); 4042} 4043 4044namespace { 4045 class FindExternalLexicalDeclsVisitor { 4046 ASTReader &Reader; 4047 const DeclContext *DC; 4048 bool (*isKindWeWant)(Decl::Kind); 4049 4050 SmallVectorImpl<Decl*> &Decls; 4051 bool PredefsVisited[NUM_PREDEF_DECL_IDS]; 4052 4053 public: 4054 FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC, 4055 bool (*isKindWeWant)(Decl::Kind), 4056 SmallVectorImpl<Decl*> &Decls) 4057 : Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls) 4058 { 4059 for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I) 4060 PredefsVisited[I] = false; 4061 } 4062 4063 static bool visit(Module &M, bool Preorder, void *UserData) { 4064 if (Preorder) 4065 return false; 4066 4067 FindExternalLexicalDeclsVisitor *This 4068 = static_cast<FindExternalLexicalDeclsVisitor *>(UserData); 4069 4070 Module::DeclContextInfosMap::iterator Info 4071 = M.DeclContextInfos.find(This->DC); 4072 if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls) 4073 return false; 4074 4075 // Load all of the declaration IDs 4076 for (const KindDeclIDPair *ID = Info->second.LexicalDecls, 4077 *IDE = ID + Info->second.NumLexicalDecls; 4078 ID != IDE; ++ID) { 4079 if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first)) 4080 continue; 4081 4082 // Don't add predefined declarations to the lexical context more 4083 // than once. 4084 if (ID->second < NUM_PREDEF_DECL_IDS) { 4085 if (This->PredefsVisited[ID->second]) 4086 continue; 4087 4088 This->PredefsVisited[ID->second] = true; 4089 } 4090 4091 if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) { 4092 if (!This->DC->isDeclInLexicalTraversal(D)) 4093 This->Decls.push_back(D); 4094 } 4095 } 4096 4097 return false; 4098 } 4099 }; 4100} 4101 4102ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC, 4103 bool (*isKindWeWant)(Decl::Kind), 4104 SmallVectorImpl<Decl*> &Decls) { 4105 // There might be lexical decls in multiple modules, for the TU at 4106 // least. Walk all of the modules in the order they were loaded. 4107 FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls); 4108 ModuleMgr.visitDepthFirst(&FindExternalLexicalDeclsVisitor::visit, &Visitor); 4109 ++NumLexicalDeclContextsRead; 4110 return ELR_Success; 4111} 4112 4113namespace { 4114 /// \brief Module visitor used to perform name lookup into a 4115 /// declaration context. 4116 class DeclContextNameLookupVisitor { 4117 ASTReader &Reader; 4118 const DeclContext *DC; 4119 DeclarationName Name; 4120 SmallVectorImpl<NamedDecl *> &Decls; 4121 4122 public: 4123 DeclContextNameLookupVisitor(ASTReader &Reader, 4124 const DeclContext *DC, DeclarationName Name, 4125 SmallVectorImpl<NamedDecl *> &Decls) 4126 : Reader(Reader), DC(DC), Name(Name), Decls(Decls) { } 4127 4128 static bool visit(Module &M, void *UserData) { 4129 DeclContextNameLookupVisitor *This 4130 = static_cast<DeclContextNameLookupVisitor *>(UserData); 4131 4132 // Check whether we have any visible declaration information for 4133 // this context in this module. 4134 Module::DeclContextInfosMap::iterator Info 4135 = M.DeclContextInfos.find(This->DC); 4136 if (Info == M.DeclContextInfos.end() || !Info->second.NameLookupTableData) 4137 return false; 4138 4139 // Look for this name within this module. 4140 ASTDeclContextNameLookupTable *LookupTable = 4141 (ASTDeclContextNameLookupTable*)Info->second.NameLookupTableData; 4142 ASTDeclContextNameLookupTable::iterator Pos 4143 = LookupTable->find(This->Name); 4144 if (Pos == LookupTable->end()) 4145 return false; 4146 4147 bool FoundAnything = false; 4148 ASTDeclContextNameLookupTrait::data_type Data = *Pos; 4149 for (; Data.first != Data.second; ++Data.first) { 4150 NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first); 4151 if (!ND) 4152 continue; 4153 4154 if (ND->getDeclName() != This->Name) { 4155 assert(!This->Name.getCXXNameType().isNull() && 4156 "Name mismatch without a type"); 4157 continue; 4158 } 4159 4160 // Record this declaration. 4161 FoundAnything = true; 4162 This->Decls.push_back(ND); 4163 } 4164 4165 return FoundAnything; 4166 } 4167 }; 4168} 4169 4170DeclContext::lookup_result 4171ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC, 4172 DeclarationName Name) { 4173 assert(DC->hasExternalVisibleStorage() && 4174 "DeclContext has no visible decls in storage"); 4175 if (!Name) 4176 return DeclContext::lookup_result(DeclContext::lookup_iterator(0), 4177 DeclContext::lookup_iterator(0)); 4178 4179 SmallVector<NamedDecl *, 64> Decls; 4180 DeclContextNameLookupVisitor Visitor(*this, DC, Name, Decls); 4181 ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor); 4182 ++NumVisibleDeclContextsRead; 4183 SetExternalVisibleDeclsForName(DC, Name, Decls); 4184 return const_cast<DeclContext*>(DC)->lookup(Name); 4185} 4186 4187/// \brief Under non-PCH compilation the consumer receives the objc methods 4188/// before receiving the implementation, and codegen depends on this. 4189/// We simulate this by deserializing and passing to consumer the methods of the 4190/// implementation before passing the deserialized implementation decl. 4191static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD, 4192 ASTConsumer *Consumer) { 4193 assert(ImplD && Consumer); 4194 4195 for (ObjCImplDecl::method_iterator 4196 I = ImplD->meth_begin(), E = ImplD->meth_end(); I != E; ++I) 4197 Consumer->HandleInterestingDecl(DeclGroupRef(*I)); 4198 4199 Consumer->HandleInterestingDecl(DeclGroupRef(ImplD)); 4200} 4201 4202void ASTReader::PassInterestingDeclsToConsumer() { 4203 assert(Consumer); 4204 while (!InterestingDecls.empty()) { 4205 Decl *D = InterestingDecls.front(); 4206 InterestingDecls.pop_front(); 4207 4208 if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D)) 4209 PassObjCImplDeclToConsumer(ImplD, Consumer); 4210 else 4211 Consumer->HandleInterestingDecl(DeclGroupRef(D)); 4212 } 4213} 4214 4215void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) { 4216 this->Consumer = Consumer; 4217 4218 if (!Consumer) 4219 return; 4220 4221 for (unsigned I = 0, N = ExternalDefinitions.size(); I != N; ++I) { 4222 // Force deserialization of this decl, which will cause it to be queued for 4223 // passing to the consumer. 4224 GetDecl(ExternalDefinitions[I]); 4225 } 4226 ExternalDefinitions.clear(); 4227 4228 PassInterestingDeclsToConsumer(); 4229} 4230 4231void ASTReader::PrintStats() { 4232 std::fprintf(stderr, "*** AST File Statistics:\n"); 4233 4234 unsigned NumTypesLoaded 4235 = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), 4236 QualType()); 4237 unsigned NumDeclsLoaded 4238 = DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(), 4239 (Decl *)0); 4240 unsigned NumIdentifiersLoaded 4241 = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), 4242 IdentifiersLoaded.end(), 4243 (IdentifierInfo *)0); 4244 unsigned NumSelectorsLoaded 4245 = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), 4246 SelectorsLoaded.end(), 4247 Selector()); 4248 4249 std::fprintf(stderr, " %u stat cache hits\n", NumStatHits); 4250 std::fprintf(stderr, " %u stat cache misses\n", NumStatMisses); 4251 if (unsigned TotalNumSLocEntries = getTotalNumSLocs()) 4252 std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n", 4253 NumSLocEntriesRead, TotalNumSLocEntries, 4254 ((float)NumSLocEntriesRead/TotalNumSLocEntries * 100)); 4255 if (!TypesLoaded.empty()) 4256 std::fprintf(stderr, " %u/%u types read (%f%%)\n", 4257 NumTypesLoaded, (unsigned)TypesLoaded.size(), 4258 ((float)NumTypesLoaded/TypesLoaded.size() * 100)); 4259 if (!DeclsLoaded.empty()) 4260 std::fprintf(stderr, " %u/%u declarations read (%f%%)\n", 4261 NumDeclsLoaded, (unsigned)DeclsLoaded.size(), 4262 ((float)NumDeclsLoaded/DeclsLoaded.size() * 100)); 4263 if (!IdentifiersLoaded.empty()) 4264 std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n", 4265 NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(), 4266 ((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100)); 4267 if (!SelectorsLoaded.empty()) 4268 std::fprintf(stderr, " %u/%u selectors read (%f%%)\n", 4269 NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(), 4270 ((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100)); 4271 if (TotalNumStatements) 4272 std::fprintf(stderr, " %u/%u statements read (%f%%)\n", 4273 NumStatementsRead, TotalNumStatements, 4274 ((float)NumStatementsRead/TotalNumStatements * 100)); 4275 if (TotalNumMacros) 4276 std::fprintf(stderr, " %u/%u macros read (%f%%)\n", 4277 NumMacrosRead, TotalNumMacros, 4278 ((float)NumMacrosRead/TotalNumMacros * 100)); 4279 if (TotalLexicalDeclContexts) 4280 std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n", 4281 NumLexicalDeclContextsRead, TotalLexicalDeclContexts, 4282 ((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts 4283 * 100)); 4284 if (TotalVisibleDeclContexts) 4285 std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n", 4286 NumVisibleDeclContextsRead, TotalVisibleDeclContexts, 4287 ((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts 4288 * 100)); 4289 if (TotalNumMethodPoolEntries) { 4290 std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n", 4291 NumMethodPoolEntriesRead, TotalNumMethodPoolEntries, 4292 ((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries 4293 * 100)); 4294 std::fprintf(stderr, " %u method pool misses\n", NumMethodPoolMisses); 4295 } 4296 std::fprintf(stderr, "\n"); 4297 dump(); 4298 std::fprintf(stderr, "\n"); 4299} 4300 4301template<typename Key, typename Module, unsigned InitialCapacity> 4302static void 4303dumpModuleIDMap(StringRef Name, 4304 const ContinuousRangeMap<Key, Module *, 4305 InitialCapacity> &Map) { 4306 if (Map.begin() == Map.end()) 4307 return; 4308 4309 typedef ContinuousRangeMap<Key, Module *, InitialCapacity> MapType; 4310 llvm::errs() << Name << ":\n"; 4311 for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end(); 4312 I != IEnd; ++I) { 4313 llvm::errs() << " " << I->first << " -> " << I->second->FileName 4314 << "\n"; 4315 } 4316} 4317 4318void ASTReader::dump() { 4319 llvm::errs() << "*** PCH/Module Remappings:\n"; 4320 dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap); 4321 dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap); 4322 dumpModuleIDMap("Global type map", GlobalTypeMap); 4323 dumpModuleIDMap("Global declaration map", GlobalDeclMap); 4324 dumpModuleIDMap("Global identifier map", GlobalIdentifierMap); 4325 dumpModuleIDMap("Global selector map", GlobalSelectorMap); 4326 dumpModuleIDMap("Global preprocessed entity map", 4327 GlobalPreprocessedEntityMap); 4328 4329 llvm::errs() << "\n*** PCH/Modules Loaded:"; 4330 for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(), 4331 MEnd = ModuleMgr.end(); 4332 M != MEnd; ++M) 4333 (*M)->dump(); 4334} 4335 4336/// Return the amount of memory used by memory buffers, breaking down 4337/// by heap-backed versus mmap'ed memory. 4338void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const { 4339 for (ModuleConstIterator I = ModuleMgr.begin(), 4340 E = ModuleMgr.end(); I != E; ++I) { 4341 if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) { 4342 size_t bytes = buf->getBufferSize(); 4343 switch (buf->getBufferKind()) { 4344 case llvm::MemoryBuffer::MemoryBuffer_Malloc: 4345 sizes.malloc_bytes += bytes; 4346 break; 4347 case llvm::MemoryBuffer::MemoryBuffer_MMap: 4348 sizes.mmap_bytes += bytes; 4349 break; 4350 } 4351 } 4352 } 4353} 4354 4355void ASTReader::InitializeSema(Sema &S) { 4356 SemaObj = &S; 4357 S.ExternalSource = this; 4358 4359 // Makes sure any declarations that were deserialized "too early" 4360 // still get added to the identifier's declaration chains. 4361 for (unsigned I = 0, N = PreloadedDecls.size(); I != N; ++I) { 4362 if (SemaObj->TUScope) 4363 SemaObj->TUScope->AddDecl(PreloadedDecls[I]); 4364 4365 SemaObj->IdResolver.AddDecl(PreloadedDecls[I]); 4366 } 4367 PreloadedDecls.clear(); 4368 4369 // Load the offsets of the declarations that Sema references. 4370 // They will be lazily deserialized when needed. 4371 if (!SemaDeclRefs.empty()) { 4372 assert(SemaDeclRefs.size() == 2 && "More decl refs than expected!"); 4373 if (!SemaObj->StdNamespace) 4374 SemaObj->StdNamespace = SemaDeclRefs[0]; 4375 if (!SemaObj->StdBadAlloc) 4376 SemaObj->StdBadAlloc = SemaDeclRefs[1]; 4377 } 4378 4379 if (!FPPragmaOptions.empty()) { 4380 assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS"); 4381 SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0]; 4382 } 4383 4384 if (!OpenCLExtensions.empty()) { 4385 unsigned I = 0; 4386#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++]; 4387#include "clang/Basic/OpenCLExtensions.def" 4388 4389 assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS"); 4390 } 4391} 4392 4393IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) { 4394 IdentifierLookupVisitor Visitor(StringRef(NameStart, NameEnd - NameStart)); 4395 ModuleMgr.visit(IdentifierLookupVisitor::visit, &Visitor); 4396 return Visitor.getIdentifierInfo(); 4397} 4398 4399namespace clang { 4400 /// \brief An identifier-lookup iterator that enumerates all of the 4401 /// identifiers stored within a set of AST files. 4402 class ASTIdentifierIterator : public IdentifierIterator { 4403 /// \brief The AST reader whose identifiers are being enumerated. 4404 const ASTReader &Reader; 4405 4406 /// \brief The current index into the chain of AST files stored in 4407 /// the AST reader. 4408 unsigned Index; 4409 4410 /// \brief The current position within the identifier lookup table 4411 /// of the current AST file. 4412 ASTIdentifierLookupTable::key_iterator Current; 4413 4414 /// \brief The end position within the identifier lookup table of 4415 /// the current AST file. 4416 ASTIdentifierLookupTable::key_iterator End; 4417 4418 public: 4419 explicit ASTIdentifierIterator(const ASTReader &Reader); 4420 4421 virtual StringRef Next(); 4422 }; 4423} 4424 4425ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader) 4426 : Reader(Reader), Index(Reader.ModuleMgr.size() - 1) { 4427 ASTIdentifierLookupTable *IdTable 4428 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable; 4429 Current = IdTable->key_begin(); 4430 End = IdTable->key_end(); 4431} 4432 4433StringRef ASTIdentifierIterator::Next() { 4434 while (Current == End) { 4435 // If we have exhausted all of our AST files, we're done. 4436 if (Index == 0) 4437 return StringRef(); 4438 4439 --Index; 4440 ASTIdentifierLookupTable *IdTable 4441 = (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index]. 4442 IdentifierLookupTable; 4443 Current = IdTable->key_begin(); 4444 End = IdTable->key_end(); 4445 } 4446 4447 // We have any identifiers remaining in the current AST file; return 4448 // the next one. 4449 std::pair<const char*, unsigned> Key = *Current; 4450 ++Current; 4451 return StringRef(Key.first, Key.second); 4452} 4453 4454IdentifierIterator *ASTReader::getIdentifiers() const { 4455 return new ASTIdentifierIterator(*this); 4456} 4457 4458namespace clang { namespace serialization { 4459 class ReadMethodPoolVisitor { 4460 ASTReader &Reader; 4461 Selector Sel; 4462 llvm::SmallVector<ObjCMethodDecl *, 4> InstanceMethods; 4463 llvm::SmallVector<ObjCMethodDecl *, 4> FactoryMethods; 4464 4465 /// \brief Build an ObjCMethodList from a vector of Objective-C method 4466 /// declarations. 4467 ObjCMethodList 4468 buildObjCMethodList(const SmallVectorImpl<ObjCMethodDecl *> &Vec) const 4469 { 4470 ObjCMethodList List; 4471 ObjCMethodList *Prev = 0; 4472 for (unsigned I = 0, N = Vec.size(); I != N; ++I) { 4473 if (!List.Method) { 4474 // This is the first method, which is the easy case. 4475 List.Method = Vec[I]; 4476 Prev = &List; 4477 continue; 4478 } 4479 4480 ObjCMethodList *Mem = 4481 Reader.getSema()->BumpAlloc.Allocate<ObjCMethodList>(); 4482 Prev->Next = new (Mem) ObjCMethodList(Vec[I], 0); 4483 Prev = Prev->Next; 4484 } 4485 4486 return List; 4487 } 4488 4489 public: 4490 ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel) 4491 : Reader(Reader), Sel(Sel) { } 4492 4493 static bool visit(Module &M, void *UserData) { 4494 ReadMethodPoolVisitor *This 4495 = static_cast<ReadMethodPoolVisitor *>(UserData); 4496 4497 if (!M.SelectorLookupTable) 4498 return false; 4499 4500 ASTSelectorLookupTable *PoolTable 4501 = (ASTSelectorLookupTable*)M.SelectorLookupTable; 4502 ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel); 4503 if (Pos == PoolTable->end()) 4504 return false; 4505 4506 ++This->Reader.NumSelectorsRead; 4507 // FIXME: Not quite happy with the statistics here. We probably should 4508 // disable this tracking when called via LoadSelector. 4509 // Also, should entries without methods count as misses? 4510 ++This->Reader.NumMethodPoolEntriesRead; 4511 ASTSelectorLookupTrait::data_type Data = *Pos; 4512 if (This->Reader.DeserializationListener) 4513 This->Reader.DeserializationListener->SelectorRead(Data.ID, 4514 This->Sel); 4515 4516 This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end()); 4517 This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end()); 4518 return true; 4519 } 4520 4521 /// \brief Retrieve the instance methods found by this visitor. 4522 ObjCMethodList getInstanceMethods() const { 4523 return buildObjCMethodList(InstanceMethods); 4524 } 4525 4526 /// \brief Retrieve the instance methods found by this visitor. 4527 ObjCMethodList getFactoryMethods() const { 4528 return buildObjCMethodList(FactoryMethods); 4529 } 4530 }; 4531} } // end namespace clang::serialization 4532 4533std::pair<ObjCMethodList, ObjCMethodList> 4534ASTReader::ReadMethodPool(Selector Sel) { 4535 ReadMethodPoolVisitor Visitor(*this, Sel); 4536 ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor); 4537 std::pair<ObjCMethodList, ObjCMethodList> Result; 4538 Result.first = Visitor.getInstanceMethods(); 4539 Result.second = Visitor.getFactoryMethods(); 4540 4541 if (!Result.first.Method && !Result.second.Method) 4542 ++NumMethodPoolMisses; 4543 return Result; 4544} 4545 4546void ASTReader::ReadKnownNamespaces( 4547 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 4548 Namespaces.clear(); 4549 4550 for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) { 4551 if (NamespaceDecl *Namespace 4552 = dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I]))) 4553 Namespaces.push_back(Namespace); 4554 } 4555} 4556 4557void ASTReader::ReadTentativeDefinitions( 4558 SmallVectorImpl<VarDecl *> &TentativeDefs) { 4559 for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) { 4560 VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I])); 4561 if (Var) 4562 TentativeDefs.push_back(Var); 4563 } 4564 TentativeDefinitions.clear(); 4565} 4566 4567void ASTReader::ReadUnusedFileScopedDecls( 4568 SmallVectorImpl<const DeclaratorDecl *> &Decls) { 4569 for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) { 4570 DeclaratorDecl *D 4571 = dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I])); 4572 if (D) 4573 Decls.push_back(D); 4574 } 4575 UnusedFileScopedDecls.clear(); 4576} 4577 4578void ASTReader::ReadDelegatingConstructors( 4579 SmallVectorImpl<CXXConstructorDecl *> &Decls) { 4580 for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) { 4581 CXXConstructorDecl *D 4582 = dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I])); 4583 if (D) 4584 Decls.push_back(D); 4585 } 4586 DelegatingCtorDecls.clear(); 4587} 4588 4589void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) { 4590 for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) { 4591 TypedefNameDecl *D 4592 = dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I])); 4593 if (D) 4594 Decls.push_back(D); 4595 } 4596 ExtVectorDecls.clear(); 4597} 4598 4599void ASTReader::ReadDynamicClasses(SmallVectorImpl<CXXRecordDecl *> &Decls) { 4600 for (unsigned I = 0, N = DynamicClasses.size(); I != N; ++I) { 4601 CXXRecordDecl *D 4602 = dyn_cast_or_null<CXXRecordDecl>(GetDecl(DynamicClasses[I])); 4603 if (D) 4604 Decls.push_back(D); 4605 } 4606 DynamicClasses.clear(); 4607} 4608 4609void 4610ASTReader::ReadLocallyScopedExternalDecls(SmallVectorImpl<NamedDecl *> &Decls) { 4611 for (unsigned I = 0, N = LocallyScopedExternalDecls.size(); I != N; ++I) { 4612 NamedDecl *D 4613 = dyn_cast_or_null<NamedDecl>(GetDecl(LocallyScopedExternalDecls[I])); 4614 if (D) 4615 Decls.push_back(D); 4616 } 4617 LocallyScopedExternalDecls.clear(); 4618} 4619 4620void ASTReader::ReadReferencedSelectors( 4621 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) { 4622 if (ReferencedSelectorsData.empty()) 4623 return; 4624 4625 // If there are @selector references added them to its pool. This is for 4626 // implementation of -Wselector. 4627 unsigned int DataSize = ReferencedSelectorsData.size()-1; 4628 unsigned I = 0; 4629 while (I < DataSize) { 4630 Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]); 4631 SourceLocation SelLoc 4632 = SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]); 4633 Sels.push_back(std::make_pair(Sel, SelLoc)); 4634 } 4635 ReferencedSelectorsData.clear(); 4636} 4637 4638void ASTReader::ReadWeakUndeclaredIdentifiers( 4639 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) { 4640 if (WeakUndeclaredIdentifiers.empty()) 4641 return; 4642 4643 for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) { 4644 IdentifierInfo *WeakId 4645 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4646 IdentifierInfo *AliasId 4647 = DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]); 4648 SourceLocation Loc 4649 = SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]); 4650 bool Used = WeakUndeclaredIdentifiers[I++]; 4651 WeakInfo WI(AliasId, Loc); 4652 WI.setUsed(Used); 4653 WeakIDs.push_back(std::make_pair(WeakId, WI)); 4654 } 4655 WeakUndeclaredIdentifiers.clear(); 4656} 4657 4658void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) { 4659 for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) { 4660 ExternalVTableUse VT; 4661 VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++])); 4662 VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]); 4663 VT.DefinitionRequired = VTableUses[Idx++]; 4664 VTables.push_back(VT); 4665 } 4666 4667 VTableUses.clear(); 4668} 4669 4670void ASTReader::ReadPendingInstantiations( 4671 SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) { 4672 for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) { 4673 ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++])); 4674 SourceLocation Loc 4675 = SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]); 4676 Pending.push_back(std::make_pair(D, Loc)); 4677 } 4678 PendingInstantiations.clear(); 4679} 4680 4681void ASTReader::LoadSelector(Selector Sel) { 4682 // It would be complicated to avoid reading the methods anyway. So don't. 4683 ReadMethodPool(Sel); 4684} 4685 4686void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) { 4687 assert(ID && "Non-zero identifier ID required"); 4688 assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range"); 4689 IdentifiersLoaded[ID - 1] = II; 4690 if (DeserializationListener) 4691 DeserializationListener->IdentifierRead(ID, II); 4692} 4693 4694/// \brief Set the globally-visible declarations associated with the given 4695/// identifier. 4696/// 4697/// If the AST reader is currently in a state where the given declaration IDs 4698/// cannot safely be resolved, they are queued until it is safe to resolve 4699/// them. 4700/// 4701/// \param II an IdentifierInfo that refers to one or more globally-visible 4702/// declarations. 4703/// 4704/// \param DeclIDs the set of declaration IDs with the name @p II that are 4705/// visible at global scope. 4706/// 4707/// \param Nonrecursive should be true to indicate that the caller knows that 4708/// this call is non-recursive, and therefore the globally-visible declarations 4709/// will not be placed onto the pending queue. 4710void 4711ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II, 4712 const SmallVectorImpl<uint32_t> &DeclIDs, 4713 bool Nonrecursive) { 4714 if (NumCurrentElementsDeserializing && !Nonrecursive) { 4715 PendingIdentifierInfos.push_back(PendingIdentifierInfo()); 4716 PendingIdentifierInfo &PII = PendingIdentifierInfos.back(); 4717 PII.II = II; 4718 PII.DeclIDs.append(DeclIDs.begin(), DeclIDs.end()); 4719 return; 4720 } 4721 4722 for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { 4723 NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); 4724 if (SemaObj) { 4725 if (SemaObj->TUScope) { 4726 // Introduce this declaration into the translation-unit scope 4727 // and add it to the declaration chain for this identifier, so 4728 // that (unqualified) name lookup will find it. 4729 SemaObj->TUScope->AddDecl(D); 4730 } 4731 SemaObj->IdResolver.AddDeclToIdentifierChain(II, D); 4732 } else { 4733 // Queue this declaration so that it will be added to the 4734 // translation unit scope and identifier's declaration chain 4735 // once a Sema object is known. 4736 PreloadedDecls.push_back(D); 4737 } 4738 } 4739} 4740 4741IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) { 4742 if (ID == 0) 4743 return 0; 4744 4745 if (IdentifiersLoaded.empty()) { 4746 Error("no identifier table in AST file"); 4747 return 0; 4748 } 4749 4750 ID -= 1; 4751 if (!IdentifiersLoaded[ID]) { 4752 GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1); 4753 assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map"); 4754 Module *M = I->second; 4755 unsigned Index = ID - M->BaseIdentifierID; 4756 const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index]; 4757 4758 // All of the strings in the AST file are preceded by a 16-bit length. 4759 // Extract that 16-bit length to avoid having to execute strlen(). 4760 // NOTE: 'StrLenPtr' is an 'unsigned char*' so that we load bytes as 4761 // unsigned integers. This is important to avoid integer overflow when 4762 // we cast them to 'unsigned'. 4763 const unsigned char *StrLenPtr = (const unsigned char*) Str - 2; 4764 unsigned StrLen = (((unsigned) StrLenPtr[0]) 4765 | (((unsigned) StrLenPtr[1]) << 8)) - 1; 4766 IdentifiersLoaded[ID] 4767 = &PP.getIdentifierTable().get(StringRef(Str, StrLen)); 4768 if (DeserializationListener) 4769 DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]); 4770 } 4771 4772 return IdentifiersLoaded[ID]; 4773} 4774 4775IdentifierInfo *ASTReader::getLocalIdentifier(Module &M, unsigned LocalID) { 4776 return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID)); 4777} 4778 4779IdentifierID ASTReader::getGlobalIdentifierID(Module &M, unsigned LocalID) { 4780 if (LocalID < NUM_PREDEF_IDENT_IDS) 4781 return LocalID; 4782 4783 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4784 = M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS); 4785 assert(I != M.IdentifierRemap.end() 4786 && "Invalid index into identifier index remap"); 4787 4788 return LocalID + I->second; 4789} 4790 4791bool ASTReader::ReadSLocEntry(int ID) { 4792 return ReadSLocEntryRecord(ID) != Success; 4793} 4794 4795Selector ASTReader::getLocalSelector(Module &M, unsigned LocalID) { 4796 return DecodeSelector(getGlobalSelectorID(M, LocalID)); 4797} 4798 4799Selector ASTReader::DecodeSelector(serialization::SelectorID ID) { 4800 if (ID == 0) 4801 return Selector(); 4802 4803 if (ID > SelectorsLoaded.size()) { 4804 Error("selector ID out of range in AST file"); 4805 return Selector(); 4806 } 4807 4808 if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == 0) { 4809 // Load this selector from the selector table. 4810 GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID); 4811 assert(I != GlobalSelectorMap.end() && "Corrupted global selector map"); 4812 Module &M = *I->second; 4813 ASTSelectorLookupTrait Trait(*this, M); 4814 unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS; 4815 SelectorsLoaded[ID - 1] = 4816 Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0); 4817 if (DeserializationListener) 4818 DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]); 4819 } 4820 4821 return SelectorsLoaded[ID - 1]; 4822} 4823 4824Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) { 4825 return DecodeSelector(ID); 4826} 4827 4828uint32_t ASTReader::GetNumExternalSelectors() { 4829 // ID 0 (the null selector) is considered an external selector. 4830 return getTotalNumSelectors() + 1; 4831} 4832 4833serialization::SelectorID 4834ASTReader::getGlobalSelectorID(Module &M, unsigned LocalID) const { 4835 if (LocalID < NUM_PREDEF_SELECTOR_IDS) 4836 return LocalID; 4837 4838 ContinuousRangeMap<uint32_t, int, 2>::iterator I 4839 = M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS); 4840 assert(I != M.SelectorRemap.end() 4841 && "Invalid index into identifier index remap"); 4842 4843 return LocalID + I->second; 4844} 4845 4846DeclarationName 4847ASTReader::ReadDeclarationName(Module &F, 4848 const RecordData &Record, unsigned &Idx) { 4849 DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; 4850 switch (Kind) { 4851 case DeclarationName::Identifier: 4852 return DeclarationName(GetIdentifierInfo(F, Record, Idx)); 4853 4854 case DeclarationName::ObjCZeroArgSelector: 4855 case DeclarationName::ObjCOneArgSelector: 4856 case DeclarationName::ObjCMultiArgSelector: 4857 return DeclarationName(ReadSelector(F, Record, Idx)); 4858 4859 case DeclarationName::CXXConstructorName: 4860 return Context.DeclarationNames.getCXXConstructorName( 4861 Context.getCanonicalType(readType(F, Record, Idx))); 4862 4863 case DeclarationName::CXXDestructorName: 4864 return Context.DeclarationNames.getCXXDestructorName( 4865 Context.getCanonicalType(readType(F, Record, Idx))); 4866 4867 case DeclarationName::CXXConversionFunctionName: 4868 return Context.DeclarationNames.getCXXConversionFunctionName( 4869 Context.getCanonicalType(readType(F, Record, Idx))); 4870 4871 case DeclarationName::CXXOperatorName: 4872 return Context.DeclarationNames.getCXXOperatorName( 4873 (OverloadedOperatorKind)Record[Idx++]); 4874 4875 case DeclarationName::CXXLiteralOperatorName: 4876 return Context.DeclarationNames.getCXXLiteralOperatorName( 4877 GetIdentifierInfo(F, Record, Idx)); 4878 4879 case DeclarationName::CXXUsingDirective: 4880 return DeclarationName::getUsingDirectiveName(); 4881 } 4882 4883 // Required to silence GCC warning 4884 return DeclarationName(); 4885} 4886 4887void ASTReader::ReadDeclarationNameLoc(Module &F, 4888 DeclarationNameLoc &DNLoc, 4889 DeclarationName Name, 4890 const RecordData &Record, unsigned &Idx) { 4891 switch (Name.getNameKind()) { 4892 case DeclarationName::CXXConstructorName: 4893 case DeclarationName::CXXDestructorName: 4894 case DeclarationName::CXXConversionFunctionName: 4895 DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx); 4896 break; 4897 4898 case DeclarationName::CXXOperatorName: 4899 DNLoc.CXXOperatorName.BeginOpNameLoc 4900 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4901 DNLoc.CXXOperatorName.EndOpNameLoc 4902 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4903 break; 4904 4905 case DeclarationName::CXXLiteralOperatorName: 4906 DNLoc.CXXLiteralOperatorName.OpNameLoc 4907 = ReadSourceLocation(F, Record, Idx).getRawEncoding(); 4908 break; 4909 4910 case DeclarationName::Identifier: 4911 case DeclarationName::ObjCZeroArgSelector: 4912 case DeclarationName::ObjCOneArgSelector: 4913 case DeclarationName::ObjCMultiArgSelector: 4914 case DeclarationName::CXXUsingDirective: 4915 break; 4916 } 4917} 4918 4919void ASTReader::ReadDeclarationNameInfo(Module &F, 4920 DeclarationNameInfo &NameInfo, 4921 const RecordData &Record, unsigned &Idx) { 4922 NameInfo.setName(ReadDeclarationName(F, Record, Idx)); 4923 NameInfo.setLoc(ReadSourceLocation(F, Record, Idx)); 4924 DeclarationNameLoc DNLoc; 4925 ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx); 4926 NameInfo.setInfo(DNLoc); 4927} 4928 4929void ASTReader::ReadQualifierInfo(Module &F, QualifierInfo &Info, 4930 const RecordData &Record, unsigned &Idx) { 4931 Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx); 4932 unsigned NumTPLists = Record[Idx++]; 4933 Info.NumTemplParamLists = NumTPLists; 4934 if (NumTPLists) { 4935 Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 4936 for (unsigned i=0; i != NumTPLists; ++i) 4937 Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx); 4938 } 4939} 4940 4941TemplateName 4942ASTReader::ReadTemplateName(Module &F, const RecordData &Record, 4943 unsigned &Idx) { 4944 TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++]; 4945 switch (Kind) { 4946 case TemplateName::Template: 4947 return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx)); 4948 4949 case TemplateName::OverloadedTemplate: { 4950 unsigned size = Record[Idx++]; 4951 UnresolvedSet<8> Decls; 4952 while (size--) 4953 Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx)); 4954 4955 return Context.getOverloadedTemplateName(Decls.begin(), Decls.end()); 4956 } 4957 4958 case TemplateName::QualifiedTemplate: { 4959 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 4960 bool hasTemplKeyword = Record[Idx++]; 4961 TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx); 4962 return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template); 4963 } 4964 4965 case TemplateName::DependentTemplate: { 4966 NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx); 4967 if (Record[Idx++]) // isIdentifier 4968 return Context.getDependentTemplateName(NNS, 4969 GetIdentifierInfo(F, Record, 4970 Idx)); 4971 return Context.getDependentTemplateName(NNS, 4972 (OverloadedOperatorKind)Record[Idx++]); 4973 } 4974 4975 case TemplateName::SubstTemplateTemplateParm: { 4976 TemplateTemplateParmDecl *param 4977 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 4978 if (!param) return TemplateName(); 4979 TemplateName replacement = ReadTemplateName(F, Record, Idx); 4980 return Context.getSubstTemplateTemplateParm(param, replacement); 4981 } 4982 4983 case TemplateName::SubstTemplateTemplateParmPack: { 4984 TemplateTemplateParmDecl *Param 4985 = ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx); 4986 if (!Param) 4987 return TemplateName(); 4988 4989 TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx); 4990 if (ArgPack.getKind() != TemplateArgument::Pack) 4991 return TemplateName(); 4992 4993 return Context.getSubstTemplateTemplateParmPack(Param, ArgPack); 4994 } 4995 } 4996 4997 llvm_unreachable("Unhandled template name kind!"); 4998} 4999 5000TemplateArgument 5001ASTReader::ReadTemplateArgument(Module &F, 5002 const RecordData &Record, unsigned &Idx) { 5003 TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++]; 5004 switch (Kind) { 5005 case TemplateArgument::Null: 5006 return TemplateArgument(); 5007 case TemplateArgument::Type: 5008 return TemplateArgument(readType(F, Record, Idx)); 5009 case TemplateArgument::Declaration: 5010 return TemplateArgument(ReadDecl(F, Record, Idx)); 5011 case TemplateArgument::Integral: { 5012 llvm::APSInt Value = ReadAPSInt(Record, Idx); 5013 QualType T = readType(F, Record, Idx); 5014 return TemplateArgument(Value, T); 5015 } 5016 case TemplateArgument::Template: 5017 return TemplateArgument(ReadTemplateName(F, Record, Idx)); 5018 case TemplateArgument::TemplateExpansion: { 5019 TemplateName Name = ReadTemplateName(F, Record, Idx); 5020 llvm::Optional<unsigned> NumTemplateExpansions; 5021 if (unsigned NumExpansions = Record[Idx++]) 5022 NumTemplateExpansions = NumExpansions - 1; 5023 return TemplateArgument(Name, NumTemplateExpansions); 5024 } 5025 case TemplateArgument::Expression: 5026 return TemplateArgument(ReadExpr(F)); 5027 case TemplateArgument::Pack: { 5028 unsigned NumArgs = Record[Idx++]; 5029 TemplateArgument *Args = new (Context) TemplateArgument[NumArgs]; 5030 for (unsigned I = 0; I != NumArgs; ++I) 5031 Args[I] = ReadTemplateArgument(F, Record, Idx); 5032 return TemplateArgument(Args, NumArgs); 5033 } 5034 } 5035 5036 llvm_unreachable("Unhandled template argument kind!"); 5037} 5038 5039TemplateParameterList * 5040ASTReader::ReadTemplateParameterList(Module &F, 5041 const RecordData &Record, unsigned &Idx) { 5042 SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx); 5043 SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx); 5044 SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx); 5045 5046 unsigned NumParams = Record[Idx++]; 5047 SmallVector<NamedDecl *, 16> Params; 5048 Params.reserve(NumParams); 5049 while (NumParams--) 5050 Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx)); 5051 5052 TemplateParameterList* TemplateParams = 5053 TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc, 5054 Params.data(), Params.size(), RAngleLoc); 5055 return TemplateParams; 5056} 5057 5058void 5059ASTReader:: 5060ReadTemplateArgumentList(SmallVector<TemplateArgument, 8> &TemplArgs, 5061 Module &F, const RecordData &Record, 5062 unsigned &Idx) { 5063 unsigned NumTemplateArgs = Record[Idx++]; 5064 TemplArgs.reserve(NumTemplateArgs); 5065 while (NumTemplateArgs--) 5066 TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx)); 5067} 5068 5069/// \brief Read a UnresolvedSet structure. 5070void ASTReader::ReadUnresolvedSet(Module &F, UnresolvedSetImpl &Set, 5071 const RecordData &Record, unsigned &Idx) { 5072 unsigned NumDecls = Record[Idx++]; 5073 while (NumDecls--) { 5074 NamedDecl *D = ReadDeclAs<NamedDecl>(F, Record, Idx); 5075 AccessSpecifier AS = (AccessSpecifier)Record[Idx++]; 5076 Set.addDecl(D, AS); 5077 } 5078} 5079 5080CXXBaseSpecifier 5081ASTReader::ReadCXXBaseSpecifier(Module &F, 5082 const RecordData &Record, unsigned &Idx) { 5083 bool isVirtual = static_cast<bool>(Record[Idx++]); 5084 bool isBaseOfClass = static_cast<bool>(Record[Idx++]); 5085 AccessSpecifier AS = static_cast<AccessSpecifier>(Record[Idx++]); 5086 bool inheritConstructors = static_cast<bool>(Record[Idx++]); 5087 TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx); 5088 SourceRange Range = ReadSourceRange(F, Record, Idx); 5089 SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx); 5090 CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo, 5091 EllipsisLoc); 5092 Result.setInheritConstructors(inheritConstructors); 5093 return Result; 5094} 5095 5096std::pair<CXXCtorInitializer **, unsigned> 5097ASTReader::ReadCXXCtorInitializers(Module &F, const RecordData &Record, 5098 unsigned &Idx) { 5099 CXXCtorInitializer **CtorInitializers = 0; 5100 unsigned NumInitializers = Record[Idx++]; 5101 if (NumInitializers) { 5102 CtorInitializers 5103 = new (Context) CXXCtorInitializer*[NumInitializers]; 5104 for (unsigned i=0; i != NumInitializers; ++i) { 5105 TypeSourceInfo *BaseClassInfo = 0; 5106 bool IsBaseVirtual = false; 5107 FieldDecl *Member = 0; 5108 IndirectFieldDecl *IndirectMember = 0; 5109 CXXConstructorDecl *Target = 0; 5110 5111 CtorInitializerType Type = (CtorInitializerType)Record[Idx++]; 5112 switch (Type) { 5113 case CTOR_INITIALIZER_BASE: 5114 BaseClassInfo = GetTypeSourceInfo(F, Record, Idx); 5115 IsBaseVirtual = Record[Idx++]; 5116 break; 5117 5118 case CTOR_INITIALIZER_DELEGATING: 5119 Target = ReadDeclAs<CXXConstructorDecl>(F, Record, Idx); 5120 break; 5121 5122 case CTOR_INITIALIZER_MEMBER: 5123 Member = ReadDeclAs<FieldDecl>(F, Record, Idx); 5124 break; 5125 5126 case CTOR_INITIALIZER_INDIRECT_MEMBER: 5127 IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx); 5128 break; 5129 } 5130 5131 SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx); 5132 Expr *Init = ReadExpr(F); 5133 SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx); 5134 SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx); 5135 bool IsWritten = Record[Idx++]; 5136 unsigned SourceOrderOrNumArrayIndices; 5137 SmallVector<VarDecl *, 8> Indices; 5138 if (IsWritten) { 5139 SourceOrderOrNumArrayIndices = Record[Idx++]; 5140 } else { 5141 SourceOrderOrNumArrayIndices = Record[Idx++]; 5142 Indices.reserve(SourceOrderOrNumArrayIndices); 5143 for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i) 5144 Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx)); 5145 } 5146 5147 CXXCtorInitializer *BOMInit; 5148 if (Type == CTOR_INITIALIZER_BASE) { 5149 BOMInit = new (Context) CXXCtorInitializer(Context, BaseClassInfo, IsBaseVirtual, 5150 LParenLoc, Init, RParenLoc, 5151 MemberOrEllipsisLoc); 5152 } else if (Type == CTOR_INITIALIZER_DELEGATING) { 5153 BOMInit = new (Context) CXXCtorInitializer(Context, MemberOrEllipsisLoc, LParenLoc, 5154 Target, Init, RParenLoc); 5155 } else if (IsWritten) { 5156 if (Member) 5157 BOMInit = new (Context) CXXCtorInitializer(Context, Member, MemberOrEllipsisLoc, 5158 LParenLoc, Init, RParenLoc); 5159 else 5160 BOMInit = new (Context) CXXCtorInitializer(Context, IndirectMember, 5161 MemberOrEllipsisLoc, LParenLoc, 5162 Init, RParenLoc); 5163 } else { 5164 BOMInit = CXXCtorInitializer::Create(Context, Member, MemberOrEllipsisLoc, 5165 LParenLoc, Init, RParenLoc, 5166 Indices.data(), Indices.size()); 5167 } 5168 5169 if (IsWritten) 5170 BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices); 5171 CtorInitializers[i] = BOMInit; 5172 } 5173 } 5174 5175 return std::make_pair(CtorInitializers, NumInitializers); 5176} 5177 5178NestedNameSpecifier * 5179ASTReader::ReadNestedNameSpecifier(Module &F, 5180 const RecordData &Record, unsigned &Idx) { 5181 unsigned N = Record[Idx++]; 5182 NestedNameSpecifier *NNS = 0, *Prev = 0; 5183 for (unsigned I = 0; I != N; ++I) { 5184 NestedNameSpecifier::SpecifierKind Kind 5185 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5186 switch (Kind) { 5187 case NestedNameSpecifier::Identifier: { 5188 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5189 NNS = NestedNameSpecifier::Create(Context, Prev, II); 5190 break; 5191 } 5192 5193 case NestedNameSpecifier::Namespace: { 5194 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5195 NNS = NestedNameSpecifier::Create(Context, Prev, NS); 5196 break; 5197 } 5198 5199 case NestedNameSpecifier::NamespaceAlias: { 5200 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5201 NNS = NestedNameSpecifier::Create(Context, Prev, Alias); 5202 break; 5203 } 5204 5205 case NestedNameSpecifier::TypeSpec: 5206 case NestedNameSpecifier::TypeSpecWithTemplate: { 5207 const Type *T = readType(F, Record, Idx).getTypePtrOrNull(); 5208 if (!T) 5209 return 0; 5210 5211 bool Template = Record[Idx++]; 5212 NNS = NestedNameSpecifier::Create(Context, Prev, Template, T); 5213 break; 5214 } 5215 5216 case NestedNameSpecifier::Global: { 5217 NNS = NestedNameSpecifier::GlobalSpecifier(Context); 5218 // No associated value, and there can't be a prefix. 5219 break; 5220 } 5221 } 5222 Prev = NNS; 5223 } 5224 return NNS; 5225} 5226 5227NestedNameSpecifierLoc 5228ASTReader::ReadNestedNameSpecifierLoc(Module &F, const RecordData &Record, 5229 unsigned &Idx) { 5230 unsigned N = Record[Idx++]; 5231 NestedNameSpecifierLocBuilder Builder; 5232 for (unsigned I = 0; I != N; ++I) { 5233 NestedNameSpecifier::SpecifierKind Kind 5234 = (NestedNameSpecifier::SpecifierKind)Record[Idx++]; 5235 switch (Kind) { 5236 case NestedNameSpecifier::Identifier: { 5237 IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx); 5238 SourceRange Range = ReadSourceRange(F, Record, Idx); 5239 Builder.Extend(Context, II, Range.getBegin(), Range.getEnd()); 5240 break; 5241 } 5242 5243 case NestedNameSpecifier::Namespace: { 5244 NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx); 5245 SourceRange Range = ReadSourceRange(F, Record, Idx); 5246 Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd()); 5247 break; 5248 } 5249 5250 case NestedNameSpecifier::NamespaceAlias: { 5251 NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx); 5252 SourceRange Range = ReadSourceRange(F, Record, Idx); 5253 Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd()); 5254 break; 5255 } 5256 5257 case NestedNameSpecifier::TypeSpec: 5258 case NestedNameSpecifier::TypeSpecWithTemplate: { 5259 bool Template = Record[Idx++]; 5260 TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx); 5261 if (!T) 5262 return NestedNameSpecifierLoc(); 5263 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5264 5265 // FIXME: 'template' keyword location not saved anywhere, so we fake it. 5266 Builder.Extend(Context, 5267 Template? T->getTypeLoc().getBeginLoc() : SourceLocation(), 5268 T->getTypeLoc(), ColonColonLoc); 5269 break; 5270 } 5271 5272 case NestedNameSpecifier::Global: { 5273 SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx); 5274 Builder.MakeGlobal(Context, ColonColonLoc); 5275 break; 5276 } 5277 } 5278 } 5279 5280 return Builder.getWithLocInContext(Context); 5281} 5282 5283SourceRange 5284ASTReader::ReadSourceRange(Module &F, const RecordData &Record, 5285 unsigned &Idx) { 5286 SourceLocation beg = ReadSourceLocation(F, Record, Idx); 5287 SourceLocation end = ReadSourceLocation(F, Record, Idx); 5288 return SourceRange(beg, end); 5289} 5290 5291/// \brief Read an integral value 5292llvm::APInt ASTReader::ReadAPInt(const RecordData &Record, unsigned &Idx) { 5293 unsigned BitWidth = Record[Idx++]; 5294 unsigned NumWords = llvm::APInt::getNumWords(BitWidth); 5295 llvm::APInt Result(BitWidth, NumWords, &Record[Idx]); 5296 Idx += NumWords; 5297 return Result; 5298} 5299 5300/// \brief Read a signed integral value 5301llvm::APSInt ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) { 5302 bool isUnsigned = Record[Idx++]; 5303 return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned); 5304} 5305 5306/// \brief Read a floating-point value 5307llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record, unsigned &Idx) { 5308 return llvm::APFloat(ReadAPInt(Record, Idx)); 5309} 5310 5311// \brief Read a string 5312std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) { 5313 unsigned Len = Record[Idx++]; 5314 std::string Result(Record.data() + Idx, Record.data() + Idx + Len); 5315 Idx += Len; 5316 return Result; 5317} 5318 5319VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record, 5320 unsigned &Idx) { 5321 unsigned Major = Record[Idx++]; 5322 unsigned Minor = Record[Idx++]; 5323 unsigned Subminor = Record[Idx++]; 5324 if (Minor == 0) 5325 return VersionTuple(Major); 5326 if (Subminor == 0) 5327 return VersionTuple(Major, Minor - 1); 5328 return VersionTuple(Major, Minor - 1, Subminor - 1); 5329} 5330 5331CXXTemporary *ASTReader::ReadCXXTemporary(Module &F, 5332 const RecordData &Record, 5333 unsigned &Idx) { 5334 CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx); 5335 return CXXTemporary::Create(Context, Decl); 5336} 5337 5338DiagnosticBuilder ASTReader::Diag(unsigned DiagID) { 5339 return Diag(SourceLocation(), DiagID); 5340} 5341 5342DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) { 5343 return Diags.Report(Loc, DiagID); 5344} 5345 5346/// \brief Retrieve the identifier table associated with the 5347/// preprocessor. 5348IdentifierTable &ASTReader::getIdentifierTable() { 5349 return PP.getIdentifierTable(); 5350} 5351 5352/// \brief Record that the given ID maps to the given switch-case 5353/// statement. 5354void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) { 5355 assert(SwitchCaseStmts[ID] == 0 && "Already have a SwitchCase with this ID"); 5356 SwitchCaseStmts[ID] = SC; 5357} 5358 5359/// \brief Retrieve the switch-case statement with the given ID. 5360SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) { 5361 assert(SwitchCaseStmts[ID] != 0 && "No SwitchCase with this ID"); 5362 return SwitchCaseStmts[ID]; 5363} 5364 5365void ASTReader::ClearSwitchCaseIDs() { 5366 SwitchCaseStmts.clear(); 5367} 5368 5369void ASTReader::FinishedDeserializing() { 5370 assert(NumCurrentElementsDeserializing && 5371 "FinishedDeserializing not paired with StartedDeserializing"); 5372 if (NumCurrentElementsDeserializing == 1) { 5373 // If any identifiers with corresponding top-level declarations have 5374 // been loaded, load those declarations now. 5375 while (!PendingIdentifierInfos.empty()) { 5376 SetGloballyVisibleDecls(PendingIdentifierInfos.front().II, 5377 PendingIdentifierInfos.front().DeclIDs, true); 5378 PendingIdentifierInfos.pop_front(); 5379 } 5380 5381 // Ready to load previous declarations of Decls that were delayed. 5382 while (!PendingPreviousDecls.empty()) { 5383 loadAndAttachPreviousDecl(PendingPreviousDecls.front().first, 5384 PendingPreviousDecls.front().second); 5385 PendingPreviousDecls.pop_front(); 5386 } 5387 5388 // We are not in recursive loading, so it's safe to pass the "interesting" 5389 // decls to the consumer. 5390 if (Consumer) 5391 PassInterestingDeclsToConsumer(); 5392 5393 assert(PendingForwardRefs.size() == 0 && 5394 "Some forward refs did not get linked to the definition!"); 5395 } 5396 --NumCurrentElementsDeserializing; 5397} 5398 5399ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, 5400 StringRef isysroot, bool DisableValidation, 5401 bool DisableStatCache) 5402 : Listener(new PCHValidator(PP, *this)), DeserializationListener(0), 5403 SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), 5404 Diags(PP.getDiagnostics()), SemaObj(0), PP(PP), Context(Context), 5405 Consumer(0), ModuleMgr(FileMgr.getFileSystemOptions()), 5406 RelocatablePCH(false), isysroot(isysroot), 5407 DisableValidation(DisableValidation), 5408 DisableStatCache(DisableStatCache), NumStatHits(0), NumStatMisses(0), 5409 NumSLocEntriesRead(0), TotalNumSLocEntries(0), 5410 NumStatementsRead(0), TotalNumStatements(0), NumMacrosRead(0), 5411 TotalNumMacros(0), NumSelectorsRead(0), NumMethodPoolEntriesRead(0), 5412 NumMethodPoolMisses(0), TotalNumMethodPoolEntries(0), 5413 NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0), 5414 NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0), 5415 TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0), 5416 NumCXXBaseSpecifiersLoaded(0) 5417{ 5418 SourceMgr.setExternalSLocEntrySource(this); 5419} 5420 5421ASTReader::~ASTReader() { 5422 for (DeclContextVisibleUpdatesPending::iterator 5423 I = PendingVisibleUpdates.begin(), 5424 E = PendingVisibleUpdates.end(); 5425 I != E; ++I) { 5426 for (DeclContextVisibleUpdates::iterator J = I->second.begin(), 5427 F = I->second.end(); 5428 J != F; ++J) 5429 delete static_cast<ASTDeclContextNameLookupTable*>(J->first); 5430 } 5431} 5432