clang  16.0.0git
ChainedIncludesSource.cpp
Go to the documentation of this file.
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"
19 #include "clang/Lex/Preprocessor.h"
21 #include "clang/Parse/ParseAST.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,
60  ASTDeserializationListener *deserialListener = nullptr) {
61  Preprocessor &PP = CI.getPreprocessor();
62  std::unique_ptr<ASTReader> Reader;
63  Reader.reset(new ASTReader(
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(),
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:
85  break;
86  }
87  return nullptr;
88 }
89 
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 
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 =
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());
123  new DiagnosticsEngine(DiagID, &CI.getDiagnosticOpts(), DiagClient));
124 
125  std::unique_ptr<CompilerInstance> Clang(
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>();
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();
151  PP.getLangOpts());
152  } else {
153  assert(!SerialBufs.empty());
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 
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 }
Builtins.h
clang::ASTReader::HadErrors
@ HadErrors
The AST file has errors.
Definition: ASTReader.h:407
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::ASTReader::Failure
@ Failure
The AST file itself appears corrupted.
Definition: ASTReader.h:390
llvm::SmallVector
Definition: LLVM.h:38
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
TargetInfo.h
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:192
clang::FrontendInputFile
An input file for the front end.
Definition: FrontendOptions.h:218
ASTWriter.h
clang::InputKind
The kind of a file that we've been handed as an input.
Definition: FrontendOptions.h:148
clang::Preprocessor::setPredefines
void setPredefines(std::string P)
Set the predefines for this Preprocessor.
Definition: Preprocessor.h:1375
clang::CompilerInstance::getPCHContainerReader
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
Definition: CompilerInstance.h:542
clang::Preprocessor::getIdentifierTable
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:1068
clang::FrontendOptions::Inputs
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
Definition: FrontendOptions.h:426
clang::Preprocessor::getLangOpts
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:1061
Preprocessor.h
clang::TU_Prefix
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:920
clang::ASTReader::Success
@ Success
The control block was read successfully.
Definition: ASTReader.h:387
MultiplexExternalSemaSource.h
clang::ASTReader::ARR_None
@ ARR_None
The client can't handle any AST loading failures.
Definition: ASTReader.h:1566
clang::PreprocessorOptions::ChainedIncludes
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
Definition: PreprocessorOptions.h:100
clang::ExternalSemaSource
An abstract interface that should be implemented by external AST sources that also provide informatio...
Definition: ExternalSemaSource.h:50
clang::TargetInfo::CreateTargetInfo
static TargetInfo * CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr< TargetOptions > &Opts)
Construct a target for the given options.
Definition: Targets.cpp:698
clang::CompilerInstance::getPreprocessor
Preprocessor & getPreprocessor() const
Return the current preprocessor.
Definition: CompilerInstance.h:442
clang::CompilerInstance::getASTContext
ASTContext & getASTContext() const
Definition: CompilerInstance.h:462
clang::CompilerInstance
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Definition: CompilerInstance.h:72
clang::CompilerInstance::getPreprocessorOpts
PreprocessorOptions & getPreprocessorOpts()
Definition: CompilerInstance.h:306
clang::DisableValidationForModuleKind::PCH
@ PCH
Disable validation for a precompiled header and the modules it depends on.
clang::CompilerInstance::getPCHContainerOperations
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
Definition: CompilerInstance.h:522
clang::CompilerInstance::getModuleCache
InMemoryModuleCache & getModuleCache() const
Definition: CompilerInstance.h:817
ParseAST.h
clang::Preprocessor::getBuiltinInfo
Builtin::Context & getBuiltinInfo()
Definition: Preprocessor.h:1071
clang::ASTDeserializationListener
Definition: ASTDeserializationListener.h:30
TextDiagnosticPrinter.h
clang::ASTReader::OutOfDate
@ OutOfDate
The AST file is out-of-date relative to its input files, and needs to be regenerated.
Definition: ASTReader.h:397
llvm::ArrayRef
Definition: LLVM.h:34
clang::CompilerInstance::getInvocation
CompilerInvocation & getInvocation()
Definition: CompilerInstance.h:229
clang::ASTReader::ConfigurationMismatch
@ ConfigurationMismatch
The AST file was written with a different language/target configuration.
Definition: ASTReader.h:404
createASTReader
static ASTReader * createASTReader(CompilerInstance &CI, StringRef pchFile, SmallVectorImpl< std::unique_ptr< llvm::MemoryBuffer >> &MemBufs, SmallVectorImpl< std::string > &bufNames, ASTDeserializationListener *deserialListener=nullptr)
Definition: ChainedIncludesSource.cpp:57
ASTUnit.h
clang::DiagnosticIDs
Used for handling and querying diagnostic IDs.
Definition: DiagnosticIDs.h:166
clang::ASTReader
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:359
std
Definition: Format.h:4477
clang::CompilerInstance::getDiagnosticOpts
DiagnosticOptions & getDiagnosticOpts()
Definition: CompilerInstance.h:268
clang::createChainedIncludesSource
IntrusiveRefCntPtr< ExternalSemaSource > createChainedIncludesSource(CompilerInstance &CI, IntrusiveRefCntPtr< ExternalSemaSource > &Reader)
The ChainedIncludesSource class converts headers to chained PCHs in memory, mainly for testing.
Definition: ChainedIncludesSource.cpp:90
clang
Definition: CalledOnceCheck.h:17
ASTReader.h
clang::CompilerInvocation
Helper class for holding the data necessary to invoke the compiler.
Definition: CompilerInvocation.h:193
clang::ASTReader::VersionMismatch
@ VersionMismatch
The AST file was written by a different version of Clang.
Definition: ASTReader.h:400
clang::TextDiagnosticPrinter
Definition: TextDiagnosticPrinter.h:27
CompilerInstance.h
clang::CompilerInstance::getFrontendOpts
FrontendOptions & getFrontendOpts()
Definition: CompilerInstance.h:282
clang::serialization::MK_PCH
@ MK_PCH
File is a PCH file treated as such.
Definition: ModuleFile.h:50
llvm::SmallVectorImpl
Definition: Randstruct.h:18
PreprocessorOptions.h
clang::Preprocessor
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:129
clang::ParseAST
void ParseAST(Preprocessor &pp, ASTConsumer *C, ASTContext &Ctx, bool PrintStats=false, TranslationUnitKind TUKind=TU_Complete, CodeCompleteConsumer *CompletionConsumer=nullptr, bool SkipFunctionBodies=false)
Parse the entire file specified, notifying the ASTConsumer as the file is parsed.
Definition: ParseAST.cpp:99
clang::ExternalASTSource
Abstract interface for external sources of AST nodes.
Definition: ExternalASTSource.h:60
clang::Builtin::Context::initializeBuiltins
void initializeBuiltins(IdentifierTable &Table, const LangOptions &LangOpts)
Mark the identifiers for all the builtins with their appropriate builtin ID # and mark any non-portab...
Definition: Builtins.cpp:102
llvm::IntrusiveRefCntPtr
Definition: LLVM.h:47
clang::DiagnosticOptions
Options for controlling the compiler diagnostics engine.
Definition: DiagnosticOptions.h:70
clang::ASTReader::Missing
@ Missing
The AST file was missing.
Definition: ASTReader.h:393