1//===------ Interpreter.cpp - Incremental Compilation and Execution -------===//
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 implements the component which performs incremental code
10// compilation and execution.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Interpreter/Interpreter.h"
15
16#include "IncrementalExecutor.h"
17#include "IncrementalParser.h"
18
19#include "clang/AST/ASTContext.h"
20#include "clang/Basic/TargetInfo.h"
21#include "clang/CodeGen/ModuleBuilder.h"
22#include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
23#include "clang/Driver/Compilation.h"
24#include "clang/Driver/Driver.h"
25#include "clang/Driver/Job.h"
26#include "clang/Driver/Options.h"
27#include "clang/Driver/Tool.h"
28#include "clang/Frontend/CompilerInstance.h"
29#include "clang/Frontend/TextDiagnosticBuffer.h"
30#include "clang/Lex/PreprocessorOptions.h"
31
32#include "llvm/IR/Module.h"
33#include "llvm/Support/Host.h"
34
35using namespace clang;
36
37// FIXME: Figure out how to unify with namespace init_convenience from
38//        tools/clang-import-test/clang-import-test.cpp and
39//        examples/clang-interpreter/main.cpp
40namespace {
41/// Retrieves the clang CC1 specific flags out of the compilation's jobs.
42/// \returns NULL on error.
43static llvm::Expected<const llvm::opt::ArgStringList *>
44GetCC1Arguments(DiagnosticsEngine *Diagnostics,
45                driver::Compilation *Compilation) {
46  // We expect to get back exactly one Command job, if we didn't something
47  // failed. Extract that job from the Compilation.
48  const driver::JobList &Jobs = Compilation->getJobs();
49  if (!Jobs.size() || !isa<driver::Command>(*Jobs.begin()))
50    return llvm::createStringError(std::errc::state_not_recoverable,
51                                   "Driver initialization failed. "
52                                   "Unable to create a driver job");
53
54  // The one job we find should be to invoke clang again.
55  const driver::Command *Cmd = cast<driver::Command>(&(*Jobs.begin()));
56  if (llvm::StringRef(Cmd->getCreator().getName()) != "clang")
57    return llvm::createStringError(std::errc::state_not_recoverable,
58                                   "Driver initialization failed");
59
60  return &Cmd->getArguments();
61}
62
63static llvm::Expected<std::unique_ptr<CompilerInstance>>
64CreateCI(const llvm::opt::ArgStringList &Argv) {
65  std::unique_ptr<CompilerInstance> Clang(new CompilerInstance());
66  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
67
68  // Register the support for object-file-wrapped Clang modules.
69  // FIXME: Clang should register these container operations automatically.
70  auto PCHOps = Clang->getPCHContainerOperations();
71  PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
72  PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
73
74  // Buffer diagnostics from argument parsing so that we can output them using
75  // a well formed diagnostic object.
76  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
77  TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
78  DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
79  bool Success = CompilerInvocation::CreateFromArgs(
80      Clang->getInvocation(), llvm::makeArrayRef(Argv.begin(), Argv.size()),
81      Diags);
82
83  // Infer the builtin include path if unspecified.
84  if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
85      Clang->getHeaderSearchOpts().ResourceDir.empty())
86    Clang->getHeaderSearchOpts().ResourceDir =
87        CompilerInvocation::GetResourcesPath(Argv[0], nullptr);
88
89  // Create the actual diagnostics engine.
90  Clang->createDiagnostics();
91  if (!Clang->hasDiagnostics())
92    return llvm::createStringError(std::errc::state_not_recoverable,
93                                   "Initialization failed. "
94                                   "Unable to create diagnostics engine");
95
96  DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
97  if (!Success)
98    return llvm::createStringError(std::errc::state_not_recoverable,
99                                   "Initialization failed. "
100                                   "Unable to flush diagnostics");
101
102  // FIXME: Merge with CompilerInstance::ExecuteAction.
103  llvm::MemoryBuffer *MB = llvm::MemoryBuffer::getMemBuffer("").release();
104  Clang->getPreprocessorOpts().addRemappedFile("<<< inputs >>>", MB);
105
106  Clang->setTarget(TargetInfo::CreateTargetInfo(
107      Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
108  if (!Clang->hasTarget())
109    return llvm::createStringError(std::errc::state_not_recoverable,
110                                   "Initialization failed. "
111                                   "Target is missing");
112
113  Clang->getTarget().adjust(Clang->getLangOpts());
114
115  return std::move(Clang);
116}
117
118} // anonymous namespace
119
120llvm::Expected<std::unique_ptr<CompilerInstance>>
121IncrementalCompilerBuilder::create(std::vector<const char *> &ClangArgv) {
122
123  // If we don't know ClangArgv0 or the address of main() at this point, try
124  // to guess it anyway (it's possible on some platforms).
125  std::string MainExecutableName =
126      llvm::sys::fs::getMainExecutable(nullptr, nullptr);
127
128  ClangArgv.insert(ClangArgv.begin(), MainExecutableName.c_str());
129
130  // Prepending -c to force the driver to do something if no action was
131  // specified. By prepending we allow users to override the default
132  // action and use other actions in incremental mode.
133  // FIXME: Print proper driver diagnostics if the driver flags are wrong.
134  ClangArgv.insert(ClangArgv.begin() + 1, "-c");
135
136  if (!llvm::is_contained(ClangArgv, " -x")) {
137    // We do C++ by default; append right after argv[0] if no "-x" given
138    ClangArgv.push_back("-x");
139    ClangArgv.push_back("c++");
140  }
141
142  // Put a dummy C++ file on to ensure there's at least one compile job for the
143  // driver to construct.
144  ClangArgv.push_back("<<< inputs >>>");
145
146  CompilerInvocation Invocation;
147  // Buffer diagnostics from argument parsing so that we can output them using a
148  // well formed diagnostic object.
149  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
150  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
151  TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
152  DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
153  unsigned MissingArgIndex, MissingArgCount;
154  const llvm::opt::OptTable &Opts = driver::getDriverOptTable();
155  llvm::opt::InputArgList ParsedArgs =
156      Opts.ParseArgs(ArrayRef<const char *>(ClangArgv).slice(1),
157                     MissingArgIndex, MissingArgCount);
158  ParseDiagnosticArgs(*DiagOpts, ParsedArgs, &Diags);
159
160  driver::Driver Driver(/*MainBinaryName=*/ClangArgv[0],
161                        llvm::sys::getProcessTriple(), Diags);
162  Driver.setCheckInputsExist(false); // the input comes from mem buffers
163  llvm::ArrayRef<const char *> RF = llvm::makeArrayRef(ClangArgv);
164  std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF));
165
166  if (Compilation->getArgs().hasArg(driver::options::OPT_v))
167    Compilation->getJobs().Print(llvm::errs(), "\n", /*Quote=*/false);
168
169  auto ErrOrCC1Args = GetCC1Arguments(&Diags, Compilation.get());
170  if (auto Err = ErrOrCC1Args.takeError())
171    return std::move(Err);
172
173  return CreateCI(**ErrOrCC1Args);
174}
175
176Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI,
177                         llvm::Error &Err) {
178  llvm::ErrorAsOutParameter EAO(&Err);
179  auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
180  TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx));
181  IncrParser = std::make_unique<IncrementalParser>(std::move(CI),
182                                                   *TSCtx->getContext(), Err);
183}
184
185Interpreter::~Interpreter() {}
186
187llvm::Expected<std::unique_ptr<Interpreter>>
188Interpreter::create(std::unique_ptr<CompilerInstance> CI) {
189  llvm::Error Err = llvm::Error::success();
190  auto Interp =
191      std::unique_ptr<Interpreter>(new Interpreter(std::move(CI), Err));
192  if (Err)
193    return std::move(Err);
194  return std::move(Interp);
195}
196
197const CompilerInstance *Interpreter::getCompilerInstance() const {
198  return IncrParser->getCI();
199}
200
201llvm::Expected<Transaction &> Interpreter::Parse(llvm::StringRef Code) {
202  return IncrParser->Parse(Code);
203}
204
205llvm::Error Interpreter::Execute(Transaction &T) {
206  assert(T.TheModule);
207  if (!IncrExecutor) {
208    const llvm::Triple &Triple =
209        getCompilerInstance()->getASTContext().getTargetInfo().getTriple();
210    llvm::Error Err = llvm::Error::success();
211    IncrExecutor = std::make_unique<IncrementalExecutor>(*TSCtx, Err, Triple);
212
213    if (Err)
214      return Err;
215  }
216  // FIXME: Add a callback to retain the llvm::Module once the JIT is done.
217  if (auto Err = IncrExecutor->addModule(std::move(T.TheModule)))
218    return Err;
219
220  if (auto Err = IncrExecutor->runCtors())
221    return Err;
222
223  return llvm::Error::success();
224}
225