1 //===- ChainedIncludesSource.cpp - Chained PCHs in Memory -------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the ChainedIncludesSource class, which converts headers 11 // to chained PCHs in memory, mainly used for testing. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "clang/Basic/TargetInfo.h" 16 #include "clang/Frontend/ASTUnit.h" 17 #include "clang/Frontend/CompilerInstance.h" 18 #include "clang/Frontend/TextDiagnosticPrinter.h" 19 #include "clang/Lex/Preprocessor.h" 20 #include "clang/Parse/ParseAST.h" 21 #include "clang/Serialization/ASTReader.h" 22 #include "clang/Serialization/ASTWriter.h" 23 #include "llvm/Support/MemoryBuffer.h" 24 25 using namespace clang; 26 27 namespace { 28 class ChainedIncludesSource : public ExternalSemaSource { 29 public: 30 virtual ~ChainedIncludesSource(); 31 32 ExternalSemaSource &getFinalReader() const { return *FinalReader; } 33 34 std::vector<CompilerInstance *> CIs; 35 IntrusiveRefCntPtr<ExternalSemaSource> FinalReader; 36 37 protected: 38 //===----------------------------------------------------------------------===// 39 // ExternalASTSource interface. 40 //===----------------------------------------------------------------------===// 41 42 Decl *GetExternalDecl(uint32_t ID) override; 43 Selector GetExternalSelector(uint32_t ID) override; 44 uint32_t GetNumExternalSelectors() override; 45 Stmt *GetExternalDeclStmt(uint64_t Offset) override; 46 CXXBaseSpecifier *GetExternalCXXBaseSpecifiers(uint64_t Offset) override; 47 bool FindExternalVisibleDeclsByName(const DeclContext *DC, 48 DeclarationName Name) override; 49 ExternalLoadResult 50 FindExternalLexicalDecls(const DeclContext *DC, 51 bool (*isKindWeWant)(Decl::Kind), 52 SmallVectorImpl<Decl *> &Result) override; 53 void CompleteType(TagDecl *Tag) override; 54 void CompleteType(ObjCInterfaceDecl *Class) override; 55 void StartedDeserializing() override; 56 void FinishedDeserializing() override; 57 void StartTranslationUnit(ASTConsumer *Consumer) override; 58 void PrintStats() override; 59 60 /// Return the amount of memory used by memory buffers, breaking down 61 /// by heap-backed versus mmap'ed memory. 62 void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override; 63 64 //===----------------------------------------------------------------------===// 65 // ExternalSemaSource interface. 66 //===----------------------------------------------------------------------===// 67 68 void InitializeSema(Sema &S) override; 69 void ForgetSema() override; 70 void ReadMethodPool(Selector Sel) override; 71 bool LookupUnqualified(LookupResult &R, Scope *S) override; 72 }; 73 } 74 75 static ASTReader * 76 createASTReader(CompilerInstance &CI, StringRef pchFile, 77 SmallVectorImpl<std::unique_ptr<llvm::MemoryBuffer>> &MemBufs, 78 SmallVectorImpl<std::string> &bufNames, 79 ASTDeserializationListener *deserialListener = nullptr) { 80 Preprocessor &PP = CI.getPreprocessor(); 81 std::unique_ptr<ASTReader> Reader; 82 Reader.reset(new ASTReader(PP, CI.getASTContext(), /*isysroot=*/"", 83 /*DisableValidation=*/true)); 84 for (unsigned ti = 0; ti < bufNames.size(); ++ti) { 85 StringRef sr(bufNames[ti]); 86 Reader->addInMemoryBuffer(sr, std::move(MemBufs[ti])); 87 } 88 Reader->setDeserializationListener(deserialListener); 89 switch (Reader->ReadAST(pchFile, serialization::MK_PCH, SourceLocation(), 90 ASTReader::ARR_None)) { 91 case ASTReader::Success: 92 // Set the predefines buffer as suggested by the PCH reader. 93 PP.setPredefines(Reader->getSuggestedPredefines()); 94 return Reader.release(); 95 96 case ASTReader::Failure: 97 case ASTReader::Missing: 98 case ASTReader::OutOfDate: 99 case ASTReader::VersionMismatch: 100 case ASTReader::ConfigurationMismatch: 101 case ASTReader::HadErrors: 102 break; 103 } 104 return nullptr; 105 } 106 107 ChainedIncludesSource::~ChainedIncludesSource() { 108 for (unsigned i = 0, e = CIs.size(); i != e; ++i) 109 delete CIs[i]; 110 } 111 112 IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource( 113 CompilerInstance &CI, IntrusiveRefCntPtr<ExternalSemaSource> &Reader) { 114 115 std::vector<std::string> &includes = CI.getPreprocessorOpts().ChainedIncludes; 116 assert(!includes.empty() && "No '-chain-include' in options!"); 117 118 IntrusiveRefCntPtr<ChainedIncludesSource> source(new ChainedIncludesSource()); 119 InputKind IK = CI.getFrontendOpts().Inputs[0].getKind(); 120 121 SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 4> SerialBufs; 122 SmallVector<std::string, 4> serialBufNames; 123 124 for (unsigned i = 0, e = includes.size(); i != e; ++i) { 125 bool firstInclude = (i == 0); 126 std::unique_ptr<CompilerInvocation> CInvok; 127 CInvok.reset(new CompilerInvocation(CI.getInvocation())); 128 129 CInvok->getPreprocessorOpts().ChainedIncludes.clear(); 130 CInvok->getPreprocessorOpts().ImplicitPCHInclude.clear(); 131 CInvok->getPreprocessorOpts().ImplicitPTHInclude.clear(); 132 CInvok->getPreprocessorOpts().DisablePCHValidation = true; 133 CInvok->getPreprocessorOpts().Includes.clear(); 134 CInvok->getPreprocessorOpts().MacroIncludes.clear(); 135 CInvok->getPreprocessorOpts().Macros.clear(); 136 137 CInvok->getFrontendOpts().Inputs.clear(); 138 FrontendInputFile InputFile(includes[i], IK); 139 CInvok->getFrontendOpts().Inputs.push_back(InputFile); 140 141 TextDiagnosticPrinter *DiagClient = 142 new TextDiagnosticPrinter(llvm::errs(), new DiagnosticOptions()); 143 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 144 IntrusiveRefCntPtr<DiagnosticsEngine> Diags( 145 new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(), DiagClient)); 146 147 std::unique_ptr<CompilerInstance> Clang(new CompilerInstance()); 148 Clang->setInvocation(CInvok.release()); 149 Clang->setDiagnostics(Diags.get()); 150 Clang->setTarget(TargetInfo::CreateTargetInfo( 151 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 152 Clang->createFileManager(); 153 Clang->createSourceManager(Clang->getFileManager()); 154 Clang->createPreprocessor(TU_Prefix); 155 Clang->getDiagnosticClient().BeginSourceFile(Clang->getLangOpts(), 156 &Clang->getPreprocessor()); 157 Clang->createASTContext(); 158 159 SmallVector<char, 256> serialAST; 160 llvm::raw_svector_ostream OS(serialAST); 161 auto consumer = 162 llvm::make_unique<PCHGenerator>(Clang->getPreprocessor(), "-", nullptr, 163 /*isysroot=*/"", &OS); 164 Clang->getASTContext().setASTMutationListener( 165 consumer->GetASTMutationListener()); 166 Clang->setASTConsumer(std::move(consumer)); 167 Clang->createSema(TU_Prefix, nullptr); 168 169 if (firstInclude) { 170 Preprocessor &PP = Clang->getPreprocessor(); 171 PP.getBuiltinInfo().InitializeBuiltins(PP.getIdentifierTable(), 172 PP.getLangOpts()); 173 } else { 174 assert(!SerialBufs.empty()); 175 SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 4> Bufs; 176 // TODO: Pass through the existing MemoryBuffer instances instead of 177 // allocating new ones. 178 for (auto &SB : SerialBufs) 179 Bufs.push_back(llvm::MemoryBuffer::getMemBuffer(SB->getBuffer())); 180 std::string pchName = includes[i-1]; 181 llvm::raw_string_ostream os(pchName); 182 os << ".pch" << i-1; 183 serialBufNames.push_back(os.str()); 184 185 IntrusiveRefCntPtr<ASTReader> Reader; 186 Reader = createASTReader( 187 *Clang, pchName, Bufs, serialBufNames, 188 Clang->getASTConsumer().GetASTDeserializationListener()); 189 if (!Reader) 190 return nullptr; 191 Clang->setModuleManager(Reader); 192 Clang->getASTContext().setExternalSource(Reader); 193 } 194 195 if (!Clang->InitializeSourceManager(InputFile)) 196 return nullptr; 197 198 ParseAST(Clang->getSema()); 199 Clang->getDiagnosticClient().EndSourceFile(); 200 SerialBufs.push_back(llvm::MemoryBuffer::getMemBufferCopy(OS.str())); 201 source->CIs.push_back(Clang.release()); 202 } 203 204 assert(!SerialBufs.empty()); 205 std::string pchName = includes.back() + ".pch-final"; 206 serialBufNames.push_back(pchName); 207 Reader = createASTReader(CI, pchName, SerialBufs, serialBufNames); 208 if (!Reader) 209 return nullptr; 210 211 source->FinalReader = Reader; 212 return source; 213 } 214 215 //===----------------------------------------------------------------------===// 216 // ExternalASTSource interface. 217 //===----------------------------------------------------------------------===// 218 219 Decl *ChainedIncludesSource::GetExternalDecl(uint32_t ID) { 220 return getFinalReader().GetExternalDecl(ID); 221 } 222 Selector ChainedIncludesSource::GetExternalSelector(uint32_t ID) { 223 return getFinalReader().GetExternalSelector(ID); 224 } 225 uint32_t ChainedIncludesSource::GetNumExternalSelectors() { 226 return getFinalReader().GetNumExternalSelectors(); 227 } 228 Stmt *ChainedIncludesSource::GetExternalDeclStmt(uint64_t Offset) { 229 return getFinalReader().GetExternalDeclStmt(Offset); 230 } 231 CXXBaseSpecifier * 232 ChainedIncludesSource::GetExternalCXXBaseSpecifiers(uint64_t Offset) { 233 return getFinalReader().GetExternalCXXBaseSpecifiers(Offset); 234 } 235 bool 236 ChainedIncludesSource::FindExternalVisibleDeclsByName(const DeclContext *DC, 237 DeclarationName Name) { 238 return getFinalReader().FindExternalVisibleDeclsByName(DC, Name); 239 } 240 ExternalLoadResult 241 ChainedIncludesSource::FindExternalLexicalDecls(const DeclContext *DC, 242 bool (*isKindWeWant)(Decl::Kind), 243 SmallVectorImpl<Decl*> &Result) { 244 return getFinalReader().FindExternalLexicalDecls(DC, isKindWeWant, Result); 245 } 246 void ChainedIncludesSource::CompleteType(TagDecl *Tag) { 247 return getFinalReader().CompleteType(Tag); 248 } 249 void ChainedIncludesSource::CompleteType(ObjCInterfaceDecl *Class) { 250 return getFinalReader().CompleteType(Class); 251 } 252 void ChainedIncludesSource::StartedDeserializing() { 253 return getFinalReader().StartedDeserializing(); 254 } 255 void ChainedIncludesSource::FinishedDeserializing() { 256 return getFinalReader().FinishedDeserializing(); 257 } 258 void ChainedIncludesSource::StartTranslationUnit(ASTConsumer *Consumer) { 259 return getFinalReader().StartTranslationUnit(Consumer); 260 } 261 void ChainedIncludesSource::PrintStats() { 262 return getFinalReader().PrintStats(); 263 } 264 void ChainedIncludesSource::getMemoryBufferSizes(MemoryBufferSizes &sizes)const{ 265 for (unsigned i = 0, e = CIs.size(); i != e; ++i) { 266 if (const ExternalASTSource *eSrc = 267 CIs[i]->getASTContext().getExternalSource()) { 268 eSrc->getMemoryBufferSizes(sizes); 269 } 270 } 271 272 getFinalReader().getMemoryBufferSizes(sizes); 273 } 274 275 void ChainedIncludesSource::InitializeSema(Sema &S) { 276 return getFinalReader().InitializeSema(S); 277 } 278 void ChainedIncludesSource::ForgetSema() { 279 return getFinalReader().ForgetSema(); 280 } 281 void ChainedIncludesSource::ReadMethodPool(Selector Sel) { 282 getFinalReader().ReadMethodPool(Sel); 283 } 284 bool ChainedIncludesSource::LookupUnqualified(LookupResult &R, Scope *S) { 285 return getFinalReader().LookupUnqualified(R, S); 286 } 287 288