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/Sema/MultiplexExternalSemaSource.h" 22 #include "clang/Serialization/ASTReader.h" 23 #include "clang/Serialization/ASTWriter.h" 24 #include "llvm/Support/MemoryBuffer.h" 25 26 using namespace clang; 27 28 namespace { 29 class ChainedIncludesSourceImpl : public ExternalSemaSource { 30 public: 31 ChainedIncludesSourceImpl(std::vector<std::unique_ptr<CompilerInstance>> CIs) 32 : CIs(std::move(CIs)) {} 33 34 protected: 35 //===----------------------------------------------------------------------===// 36 // ExternalASTSource interface. 37 //===----------------------------------------------------------------------===// 38 39 /// Return the amount of memory used by memory buffers, breaking down 40 /// by heap-backed versus mmap'ed memory. 41 void getMemoryBufferSizes(MemoryBufferSizes &sizes) const override { 42 for (unsigned i = 0, e = CIs.size(); i != e; ++i) { 43 if (const ExternalASTSource *eSrc = 44 CIs[i]->getASTContext().getExternalSource()) { 45 eSrc->getMemoryBufferSizes(sizes); 46 } 47 } 48 } 49 50 private: 51 std::vector<std::unique_ptr<CompilerInstance>> CIs; 52 }; 53 54 /// Members of ChainedIncludesSource, factored out so we can initialize 55 /// them before we initialize the ExternalSemaSource base class. 56 struct ChainedIncludesSourceMembers { 57 ChainedIncludesSourceImpl Impl; 58 IntrusiveRefCntPtr<ExternalSemaSource> FinalReader; 59 }; 60 61 /// Use MultiplexExternalSemaSource to dispatch all ExternalSemaSource 62 /// calls to the final reader. 63 class ChainedIncludesSource 64 : private ChainedIncludesSourceMembers, 65 public MultiplexExternalSemaSource { 66 public: 67 ChainedIncludesSource(std::vector<std::unique_ptr<CompilerInstance>> CIs, 68 IntrusiveRefCntPtr<ExternalSemaSource> FinalReader) 69 : ChainedIncludesSourceMembers{{std::move(CIs)}, std::move(FinalReader)}, 70 MultiplexExternalSemaSource(Impl, *this->FinalReader) {} 71 }; 72 } 73 74 static ASTReader * 75 createASTReader(CompilerInstance &CI, StringRef pchFile, 76 SmallVectorImpl<std::unique_ptr<llvm::MemoryBuffer>> &MemBufs, 77 SmallVectorImpl<std::string> &bufNames, 78 ASTDeserializationListener *deserialListener = nullptr) { 79 Preprocessor &PP = CI.getPreprocessor(); 80 std::unique_ptr<ASTReader> Reader; 81 Reader.reset(new ASTReader(PP, CI.getASTContext(), 82 CI.getPCHContainerReader(), 83 /*Extensions=*/{ }, 84 /*isysroot=*/"", /*DisableValidation=*/true)); 85 for (unsigned ti = 0; ti < bufNames.size(); ++ti) { 86 StringRef sr(bufNames[ti]); 87 Reader->addInMemoryBuffer(sr, std::move(MemBufs[ti])); 88 } 89 Reader->setDeserializationListener(deserialListener); 90 switch (Reader->ReadAST(pchFile, serialization::MK_PCH, SourceLocation(), 91 ASTReader::ARR_None)) { 92 case ASTReader::Success: 93 // Set the predefines buffer as suggested by the PCH reader. 94 PP.setPredefines(Reader->getSuggestedPredefines()); 95 return Reader.release(); 96 97 case ASTReader::Failure: 98 case ASTReader::Missing: 99 case ASTReader::OutOfDate: 100 case ASTReader::VersionMismatch: 101 case ASTReader::ConfigurationMismatch: 102 case ASTReader::HadErrors: 103 break; 104 } 105 return nullptr; 106 } 107 108 IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource( 109 CompilerInstance &CI, IntrusiveRefCntPtr<ExternalSemaSource> &Reader) { 110 111 std::vector<std::string> &includes = CI.getPreprocessorOpts().ChainedIncludes; 112 assert(!includes.empty() && "No '-chain-include' in options!"); 113 114 std::vector<std::unique_ptr<CompilerInstance>> CIs; 115 InputKind IK = CI.getFrontendOpts().Inputs[0].getKind(); 116 117 SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 4> SerialBufs; 118 SmallVector<std::string, 4> serialBufNames; 119 120 for (unsigned i = 0, e = includes.size(); i != e; ++i) { 121 bool firstInclude = (i == 0); 122 std::unique_ptr<CompilerInvocation> CInvok; 123 CInvok.reset(new CompilerInvocation(CI.getInvocation())); 124 125 CInvok->getPreprocessorOpts().ChainedIncludes.clear(); 126 CInvok->getPreprocessorOpts().ImplicitPCHInclude.clear(); 127 CInvok->getPreprocessorOpts().ImplicitPTHInclude.clear(); 128 CInvok->getPreprocessorOpts().DisablePCHValidation = true; 129 CInvok->getPreprocessorOpts().Includes.clear(); 130 CInvok->getPreprocessorOpts().MacroIncludes.clear(); 131 CInvok->getPreprocessorOpts().Macros.clear(); 132 133 CInvok->getFrontendOpts().Inputs.clear(); 134 FrontendInputFile InputFile(includes[i], IK); 135 CInvok->getFrontendOpts().Inputs.push_back(InputFile); 136 137 TextDiagnosticPrinter *DiagClient = 138 new TextDiagnosticPrinter(llvm::errs(), new DiagnosticOptions()); 139 IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); 140 IntrusiveRefCntPtr<DiagnosticsEngine> Diags( 141 new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(), DiagClient)); 142 143 std::unique_ptr<CompilerInstance> Clang( 144 new CompilerInstance(CI.getPCHContainerOperations())); 145 Clang->setInvocation(CInvok.release()); 146 Clang->setDiagnostics(Diags.get()); 147 Clang->setTarget(TargetInfo::CreateTargetInfo( 148 Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); 149 Clang->createFileManager(); 150 Clang->createSourceManager(Clang->getFileManager()); 151 Clang->createPreprocessor(TU_Prefix); 152 Clang->getDiagnosticClient().BeginSourceFile(Clang->getLangOpts(), 153 &Clang->getPreprocessor()); 154 Clang->createASTContext(); 155 156 auto Buffer = std::make_shared<PCHBuffer>(); 157 ArrayRef<llvm::IntrusiveRefCntPtr<ModuleFileExtension>> Extensions; 158 auto consumer = llvm::make_unique<PCHGenerator>( 159 Clang->getPreprocessor(), "-", nullptr, /*isysroot=*/"", Buffer, 160 Extensions, /*AllowASTWithErrors=*/true); 161 Clang->getASTContext().setASTMutationListener( 162 consumer->GetASTMutationListener()); 163 Clang->setASTConsumer(std::move(consumer)); 164 Clang->createSema(TU_Prefix, nullptr); 165 166 if (firstInclude) { 167 Preprocessor &PP = Clang->getPreprocessor(); 168 PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(), 169 PP.getLangOpts()); 170 } else { 171 assert(!SerialBufs.empty()); 172 SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 4> Bufs; 173 // TODO: Pass through the existing MemoryBuffer instances instead of 174 // allocating new ones. 175 for (auto &SB : SerialBufs) 176 Bufs.push_back(llvm::MemoryBuffer::getMemBuffer(SB->getBuffer())); 177 std::string pchName = includes[i-1]; 178 llvm::raw_string_ostream os(pchName); 179 os << ".pch" << i-1; 180 serialBufNames.push_back(os.str()); 181 182 IntrusiveRefCntPtr<ASTReader> Reader; 183 Reader = createASTReader( 184 *Clang, pchName, Bufs, serialBufNames, 185 Clang->getASTConsumer().GetASTDeserializationListener()); 186 if (!Reader) 187 return nullptr; 188 Clang->setModuleManager(Reader); 189 Clang->getASTContext().setExternalSource(Reader); 190 } 191 192 if (!Clang->InitializeSourceManager(InputFile)) 193 return nullptr; 194 195 ParseAST(Clang->getSema()); 196 Clang->getDiagnosticClient().EndSourceFile(); 197 assert(Buffer->IsComplete && "serialization did not complete"); 198 auto &serialAST = Buffer->Data; 199 SerialBufs.push_back(llvm::MemoryBuffer::getMemBufferCopy( 200 StringRef(serialAST.data(), serialAST.size()))); 201 serialAST.clear(); 202 CIs.push_back(std::move(Clang)); 203 } 204 205 assert(!SerialBufs.empty()); 206 std::string pchName = includes.back() + ".pch-final"; 207 serialBufNames.push_back(pchName); 208 Reader = createASTReader(CI, pchName, SerialBufs, serialBufNames); 209 if (!Reader) 210 return nullptr; 211 212 return IntrusiveRefCntPtr<ChainedIncludesSource>( 213 new ChainedIncludesSource(std::move(CIs), Reader)); 214 } 215