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