| 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/Errc.h" |
| 34 |
#include "llvm/Support/Host.h" |
| 35 |
|
| 36 |
using namespace clang; |
| 37 |
|
| 38 |
// FIXME: Figure out how to unify with namespace init_convenience from |
| 39 |
// tools/clang-import-test/clang-import-test.cpp |
| 40 |
namespace { |
| 41 |
/// Retrieves the clang CC1 specific flags out of the compilation's jobs. |
| 42 |
/// \returns NULL on error. |
| 43 |
static llvm::Expected<const llvm::opt::ArgStringList *> |
| 44 |
GetCC1Arguments(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(llvm::errc::not_supported, |
| 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(llvm::errc::not_supported, |
| 58 |
"Driver initialization failed"); |
| 59 |
|
| 60 |
return &Cmd->getArguments(); |
| 61 |
} |
| 62 |
|
| 63 |
static llvm::Expected<std::unique_ptr<CompilerInstance>> |
| 64 |
CreateCI(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::ArrayRef(Argv.begin(), Argv.size()), Diags); |
| 81 |
|
| 82 |
// Infer the builtin include path if unspecified. |
| 83 |
if (Clang->getHeaderSearchOpts().UseBuiltinIncludes && |
| 84 |
Clang->getHeaderSearchOpts().ResourceDir.empty()) |
| 85 |
Clang->getHeaderSearchOpts().ResourceDir = |
| 86 |
CompilerInvocation::GetResourcesPath(Argv[0], nullptr); |
| 87 |
|
| 88 |
// Create the actual diagnostics engine. |
| 89 |
Clang->createDiagnostics(); |
| 90 |
if (!Clang->hasDiagnostics()) |
| 91 |
return llvm::createStringError(llvm::errc::not_supported, |
| 92 |
"Initialization failed. " |
| 93 |
"Unable to create diagnostics engine"); |
| 94 |
|
| 95 |
DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics()); |
| 96 |
if (!Success) |
| 97 |
return llvm::createStringError(llvm::errc::not_supported, |
| 98 |
"Initialization failed. " |
| 99 |
"Unable to flush diagnostics"); |
| 100 |
|
| 101 |
// FIXME: Merge with CompilerInstance::ExecuteAction. |
| 102 |
llvm::MemoryBuffer *MB = llvm::MemoryBuffer::getMemBuffer("").release(); |
| 103 |
Clang->getPreprocessorOpts().addRemappedFile("<<< inputs >>>", MB); |
| 104 |
|
| 105 |
Clang->setTarget(TargetInfo::CreateTargetInfo( |
| 106 |
Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); |
| 107 |
if (!Clang->hasTarget()) |
| 108 |
return llvm::createStringError(llvm::errc::not_supported, |
| 109 |
"Initialization failed. " |
| 110 |
"Target is missing"); |
| 111 |
|
| 112 |
Clang->getTarget().adjust(Clang->getDiagnostics(), Clang->getLangOpts()); |
| 113 |
|
| 114 |
// Don't clear the AST before backend codegen since we do codegen multiple |
| 115 |
// times, reusing the same AST. |
| 116 |
Clang->getCodeGenOpts().ClearASTBeforeBackend = false; |
| 117 |
|
| 118 |
Clang->getFrontendOpts().DisableFree = false; |
| 119 |
Clang->getCodeGenOpts().DisableFree = false; |
| 120 |
|
| 121 |
return std::move(Clang); |
| 122 |
} |
| 123 |
|
| 124 |
} // anonymous namespace |
| 125 |
|
| 126 |
llvm::Expected<std::unique_ptr<CompilerInstance>> |
| 127 |
IncrementalCompilerBuilder::create(std::vector<const char *> &ClangArgv) { |
| 128 |
|
| 129 |
// If we don't know ClangArgv0 or the address of main() at this point, try |
| 130 |
// to guess it anyway (it's possible on some platforms). |
| 131 |
std::string MainExecutableName = |
| 132 |
llvm::sys::fs::getMainExecutable(nullptr, nullptr); |
| 133 |
|
| 134 |
ClangArgv.insert(ClangArgv.begin(), MainExecutableName.c_str()); |
| 135 |
|
| 136 |
// Prepending -c to force the driver to do something if no action was |
| 137 |
// specified. By prepending we allow users to override the default |
| 138 |
// action and use other actions in incremental mode. |
| 139 |
// FIXME: Print proper driver diagnostics if the driver flags are wrong. |
| 140 |
// We do C++ by default; append right after argv[0] if no "-x" given |
| 141 |
ClangArgv.insert(ClangArgv.end(), "-xc++"); |
| 142 |
ClangArgv.insert(ClangArgv.end(), "-Xclang"); |
| 143 |
ClangArgv.insert(ClangArgv.end(), "-fincremental-extensions"); |
| 144 |
ClangArgv.insert(ClangArgv.end(), "-c"); |
| 145 |
|
| 146 |
// Put a dummy C++ file on to ensure there's at least one compile job for the |
| 147 |
// driver to construct. |
| 148 |
ClangArgv.push_back("<<< inputs >>>"); |
| 149 |
|
| 150 |
// Buffer diagnostics from argument parsing so that we can output them using a |
| 151 |
// well formed diagnostic object. |
| 152 |
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); |
| 153 |
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = |
| 154 |
CreateAndPopulateDiagOpts(ClangArgv); |
| 155 |
TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer; |
| 156 |
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer); |
| 157 |
|
| 158 |
driver::Driver Driver(/*MainBinaryName=*/ClangArgv[0], |
| 159 |
llvm::sys::getProcessTriple(), Diags); |
| 160 |
Driver.setCheckInputsExist(false); // the input comes from mem buffers |
| 161 |
llvm::ArrayRef<const char *> RF = llvm::ArrayRef(ClangArgv); |
| 162 |
std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF)); |
| 163 |
|
| 164 |
if (Compilation->getArgs().hasArg(driver::options::OPT_v)) |
| 165 |
Compilation->getJobs().Print(llvm::errs(), "\n", /*Quote=*/false); |
| 166 |
|
| 167 |
auto ErrOrCC1Args = GetCC1Arguments(&Diags, Compilation.get()); |
| 168 |
if (auto Err = ErrOrCC1Args.takeError()) |
| 169 |
return std::move(Err); |
| 170 |
|
| 171 |
return CreateCI(**ErrOrCC1Args); |
| 172 |
} |
| 173 |
|
| 174 |
Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI, |
| 175 |
llvm::Error &Err) { |
| 176 |
llvm::ErrorAsOutParameter EAO(&Err); |
| 177 |
auto LLVMCtx = std::make_unique<llvm::LLVMContext>(); |
| 178 |
TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx)); |
| 179 |
IncrParser = std::make_unique<IncrementalParser>(std::move(CI), |
| 180 |
*TSCtx->getContext(), Err); |
| 181 |
} |
| 182 |
|
| 183 |
Interpreter::~Interpreter() { |
| 184 |
if (IncrExecutor) { |
| 185 |
if (llvm::Error Err = IncrExecutor->cleanUp()) |
| 186 |
llvm::report_fatal_error( |
| 187 |
llvm::Twine("Failed to clean up IncrementalExecutor: ") + |
| 188 |
toString(std::move(Err))); |
| 189 |
} |
| 190 |
} |
| 191 |
|
| 192 |
llvm::Expected<std::unique_ptr<Interpreter>> |
| 193 |
Interpreter::create(std::unique_ptr<CompilerInstance> CI) { |
| 194 |
llvm::Error Err = llvm::Error::success(); |
| 195 |
auto Interp = |
| 196 |
std::unique_ptr<Interpreter>(new Interpreter(std::move(CI), Err)); |
| 197 |
if (Err) |
| 198 |
return std::move(Err); |
| 199 |
return std::move(Interp); |
| 200 |
} |
| 201 |
|
| 202 |
const CompilerInstance *Interpreter::getCompilerInstance() const { |
| 203 |
return IncrParser->getCI(); |
| 204 |
} |
| 205 |
|
| 206 |
const llvm::orc::LLJIT *Interpreter::getExecutionEngine() const { |
| 207 |
if (IncrExecutor) |
| 208 |
return IncrExecutor->getExecutionEngine(); |
| 209 |
return nullptr; |
| 210 |
} |
| 211 |
|
| 212 |
llvm::Expected<PartialTranslationUnit &> |
| 213 |
Interpreter::Parse(llvm::StringRef Code) { |
| 214 |
return IncrParser->Parse(Code); |
| 215 |
} |
| 216 |
|
| 217 |
llvm::Error Interpreter::Execute(PartialTranslationUnit &T) { |
| 218 |
assert(T.TheModule); |
| 219 |
if (!IncrExecutor) { |
| 220 |
const clang::TargetInfo &TI = |
| 221 |
getCompilerInstance()->getASTContext().getTargetInfo(); |
| 222 |
llvm::Error Err = llvm::Error::success(); |
| 223 |
IncrExecutor = std::make_unique<IncrementalExecutor>(*TSCtx, Err, TI); |
| 224 |
|
| 225 |
if (Err) |
| 226 |
return Err; |
| 227 |
} |
| 228 |
// FIXME: Add a callback to retain the llvm::Module once the JIT is done. |
| 229 |
if (auto Err = IncrExecutor->addModule(T)) |
| 230 |
return Err; |
| 231 |
|
| 232 |
if (auto Err = IncrExecutor->runCtors()) |
| 233 |
return Err; |
| 234 |
|
| 235 |
return llvm::Error::success(); |
| 236 |
} |
| 237 |
|
| 238 |
llvm::Expected<llvm::JITTargetAddress> |
| 239 |
Interpreter::getSymbolAddress(GlobalDecl GD) const { |
| 240 |
if (!IncrExecutor) |
| 241 |
return llvm::make_error<llvm::StringError>("Operation failed. " |
| 242 |
"No execution engine", |
| 243 |
std::error_code()); |
| 244 |
llvm::StringRef MangledName = IncrParser->GetMangledName(GD); |
| 245 |
return getSymbolAddress(MangledName); |
| 246 |
} |
| 247 |
|
| 248 |
llvm::Expected<llvm::JITTargetAddress> |
| 249 |
Interpreter::getSymbolAddress(llvm::StringRef IRName) const { |
| 250 |
if (!IncrExecutor) |
| 251 |
return llvm::make_error<llvm::StringError>("Operation failed. " |
| 252 |
"No execution engine", |
| 253 |
std::error_code()); |
| 254 |
|
| 255 |
return IncrExecutor->getSymbolAddress(IRName, IncrementalExecutor::IRName); |
| 256 |
} |
| 257 |
|
| 258 |
llvm::Expected<llvm::JITTargetAddress> |
| 259 |
Interpreter::getSymbolAddressFromLinkerName(llvm::StringRef Name) const { |
| 260 |
if (!IncrExecutor) |
| 261 |
return llvm::make_error<llvm::StringError>("Operation failed. " |
| 262 |
"No execution engine", |
| 263 |
std::error_code()); |
| 264 |
|
| 265 |
return IncrExecutor->getSymbolAddress(Name, IncrementalExecutor::LinkerName); |
| 266 |
} |
| 267 |
|
| 268 |
llvm::Error Interpreter::Undo(unsigned N) { |
| 269 |
|
| 270 |
std::list<PartialTranslationUnit> &PTUs = IncrParser->getPTUs(); |
| 271 |
if (N > PTUs.size()) |
| 272 |
return llvm::make_error<llvm::StringError>("Operation failed. " |
| 273 |
"Too many undos", |
| 274 |
std::error_code()); |
| 275 |
for (unsigned I = 0; I < N; I++) { |
| 276 |
if (IncrExecutor) { |
| 277 |
if (llvm::Error Err = IncrExecutor->removeModule(PTUs.back())) |
| 278 |
return Err; |
| 279 |
} |
| 280 |
|
| 281 |
IncrParser->CleanUpPTU(PTUs.back()); |
| 282 |
PTUs.pop_back(); |
| 283 |
} |
| 284 |
return llvm::Error::success(); |
| 285 |
} |