clang/lib/Frontend/ChainedIncludesSource.cpp

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