a72d7eea54
This patch improves the design of the IncrementalParser and Interpreter classes. Now the incremental parser is only responsible for building the partial translation unit declaration and the AST, while the Interpreter fills in the lower level llvm::Module and other JIT-related infrastructure. Finally the Interpreter class now orchestrates the AST and the LLVM IR with the IncrementalParser and IncrementalExecutor classes. The design improvement allows us to rework some of the logic that extracts an interpreter value into the clang::Value object. The new implementation simplifies use-cases which are used for out-of-process execution by allowing interpreter to be inherited or customized with an clang::ASTConsumer. This change will enable completing the pretty printing work which is in llvm/llvm-project#84769
122 lines
4.3 KiB
C++
122 lines
4.3 KiB
C++
//===--- IncrementalExecutor.cpp - Incremental Execution --------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the class which performs incremental code execution.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "IncrementalExecutor.h"
|
|
|
|
#include "clang/Basic/TargetInfo.h"
|
|
#include "clang/Basic/TargetOptions.h"
|
|
#include "clang/Interpreter/PartialTranslationUnit.h"
|
|
#include "llvm/ExecutionEngine/ExecutionEngine.h"
|
|
#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
|
|
#include "llvm/ExecutionEngine/Orc/Debugging/DebuggerSupport.h"
|
|
#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
|
|
#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
|
|
#include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
|
|
#include "llvm/ExecutionEngine/Orc/LLJIT.h"
|
|
#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
|
|
#include "llvm/ExecutionEngine/Orc/TargetProcess/JITLoaderGDB.h"
|
|
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include "llvm/Support/TargetSelect.h"
|
|
|
|
// Force linking some of the runtimes that helps attaching to a debugger.
|
|
LLVM_ATTRIBUTE_USED void linkComponents() {
|
|
llvm::errs() << (void *)&llvm_orc_registerJITLoaderGDBWrapper
|
|
<< (void *)&llvm_orc_registerJITLoaderGDBAllocAction;
|
|
}
|
|
|
|
namespace clang {
|
|
IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC)
|
|
: TSCtx(TSC) {}
|
|
|
|
llvm::Expected<std::unique_ptr<llvm::orc::LLJITBuilder>>
|
|
IncrementalExecutor::createDefaultJITBuilder(
|
|
llvm::orc::JITTargetMachineBuilder JTMB) {
|
|
auto JITBuilder = std::make_unique<llvm::orc::LLJITBuilder>();
|
|
JITBuilder->setJITTargetMachineBuilder(std::move(JTMB));
|
|
JITBuilder->setPrePlatformSetup([](llvm::orc::LLJIT &J) {
|
|
// Try to enable debugging of JIT'd code (only works with JITLink for
|
|
// ELF and MachO).
|
|
consumeError(llvm::orc::enableDebuggerSupport(J));
|
|
return llvm::Error::success();
|
|
});
|
|
return std::move(JITBuilder);
|
|
}
|
|
|
|
IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC,
|
|
llvm::orc::LLJITBuilder &JITBuilder,
|
|
llvm::Error &Err)
|
|
: TSCtx(TSC) {
|
|
using namespace llvm::orc;
|
|
llvm::ErrorAsOutParameter EAO(&Err);
|
|
|
|
if (auto JitOrErr = JITBuilder.create())
|
|
Jit = std::move(*JitOrErr);
|
|
else {
|
|
Err = JitOrErr.takeError();
|
|
return;
|
|
}
|
|
}
|
|
|
|
IncrementalExecutor::~IncrementalExecutor() {}
|
|
|
|
llvm::Error IncrementalExecutor::addModule(PartialTranslationUnit &PTU) {
|
|
llvm::orc::ResourceTrackerSP RT =
|
|
Jit->getMainJITDylib().createResourceTracker();
|
|
ResourceTrackers[&PTU] = RT;
|
|
|
|
return Jit->addIRModule(RT, {std::move(PTU.TheModule), TSCtx});
|
|
}
|
|
|
|
llvm::Error IncrementalExecutor::removeModule(PartialTranslationUnit &PTU) {
|
|
|
|
llvm::orc::ResourceTrackerSP RT = std::move(ResourceTrackers[&PTU]);
|
|
if (!RT)
|
|
return llvm::Error::success();
|
|
|
|
ResourceTrackers.erase(&PTU);
|
|
if (llvm::Error Err = RT->remove())
|
|
return Err;
|
|
return llvm::Error::success();
|
|
}
|
|
|
|
// Clean up the JIT instance.
|
|
llvm::Error IncrementalExecutor::cleanUp() {
|
|
// This calls the global dtors of registered modules.
|
|
return Jit->deinitialize(Jit->getMainJITDylib());
|
|
}
|
|
|
|
llvm::Error IncrementalExecutor::runCtors() const {
|
|
return Jit->initialize(Jit->getMainJITDylib());
|
|
}
|
|
|
|
llvm::Expected<llvm::orc::ExecutorAddr>
|
|
IncrementalExecutor::getSymbolAddress(llvm::StringRef Name,
|
|
SymbolNameKind NameKind) const {
|
|
using namespace llvm::orc;
|
|
auto SO = makeJITDylibSearchOrder({&Jit->getMainJITDylib(),
|
|
Jit->getPlatformJITDylib().get(),
|
|
Jit->getProcessSymbolsJITDylib().get()});
|
|
|
|
ExecutionSession &ES = Jit->getExecutionSession();
|
|
|
|
auto SymOrErr =
|
|
ES.lookup(SO, (NameKind == LinkerName) ? ES.intern(Name)
|
|
: Jit->mangleAndIntern(Name));
|
|
if (auto Err = SymOrErr.takeError())
|
|
return std::move(Err);
|
|
return SymOrErr->getAddress();
|
|
}
|
|
|
|
} // namespace clang
|