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