This is an archive of the discontinued LLVM Phabricator instance.

Differential D45897

Convert clang-interpreter to ORC JIT API
ClosedPublic

Authored by sas on Apr 20 2018, 12:47 PM.

Details

Reviewers
• ddunbar
lhames
Commits
rGb6f6192db109: Convert clang-interpreter to ORC JIT API
rC333302: Convert clang-interpreter to ORC JIT API
rL333302: Convert clang-interpreter to ORC JIT API
Summary

This mostly re-uses code from the KaleidoscopeJIT example.

Diff Detail

Repository
rL LLVM

Event Timeline

sas created this revision.Apr 20 2018, 12:47 PM
Herald added a subscriber: mgorny. · View Herald TranscriptApr 20 2018, 12:48 PM
alexander-shaposhnikov added a subscriber: alexander-shaposhnikov.Apr 20 2018, 1:09 PM
alexander-shaposhnikov added inline comments.
examples/clang-interpreter/main.cpp
52 ↗(On Diff #143367)

not needed

84 ↗(On Diff #143367)

const TargetMachine & ?

93 ↗(On Diff #143367)

const string & or maybe even StringRef and the same below

sas added inline comments.Apr 20 2018, 1:13 PM
examples/clang-interpreter/main.cpp
52 ↗(On Diff #143367)

Seems cleaner to me to have these explicit, and avoids potentiel code churn if there are changes above. Is there something in the llvm coding style that recommends skipping these?

sas updated this revision to Diff 143376.Apr 20 2018, 1:34 PM

Review comments from @alexshap.

lhames accepted this revision.May 23 2018, 4:24 PM

Looks good to me. :)

This revision is now accepted and ready to land.May 23 2018, 4:24 PM
Herald added a subscriber: mgrang. · View Herald TranscriptMay 23 2018, 4:24 PM
Closed by commit rL333302: Convert clang-interpreter to ORC JIT API (authored by sas). · Explain WhyMay 25 2018, 1:27 PM
This revision was automatically updated to reflect the committed changes.
Herald added a subscriber: llvm-commits. · View Herald TranscriptMay 25 2018, 1:27 PM

Revision Contents

PathSize
cfe/
trunk/
examples/
clang-interpreter/
2 lines
34 lines
31 lines
59 lines
328 lines
136 lines

Diff 148656

cfe/trunk/examples/clang-interpreter/CMakeLists.txt

set(LLVM_LINK_COMPONENTS set(LLVM_LINK_COMPONENTS
Core Core
ExecutionEngine ExecutionEngine
MC MC
MCJIT MCJIT
OrcJit OrcJit
Option Option
RuntimeDyld RuntimeDyld
Support Support
native native
) )
add_clang_executable(clang-interpreter add_clang_executable(clang-interpreter
main.cpp main.cpp
Invoke.cpp
Manager.cpp
) )
add_dependencies(clang-interpreter add_dependencies(clang-interpreter
clang-headers clang-headers
) )
target_link_libraries(clang-interpreter target_link_libraries(clang-interpreter
PRIVATE PRIVATE
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

cfe/trunk/examples/clang-interpreter/Invoke.h

//===-- examples/clang-interpreter/Invoke.h - Clang C Interpreter Example -===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef CLANG_EXAMPLE_INTERPRETER_INVOKE_H
#define CLANG_EXAMPLE_INTERPRETER_INVOKE_H
namespace llvm {
class ExecutionEngine;
class Function;
}
#include <string>
#include <vector>
namespace interpreter {
typedef std::vector<std::string> InvokeArgs;
typedef int (*Invoker)(llvm::ExecutionEngine *EE, llvm::Function *EntryFn,
const InvokeArgs &Args, char *const *EnvP);
int TryIt(llvm::ExecutionEngine *EE, llvm::Function *EntryFn,
const InvokeArgs &Args, char *const *EnvP,
Invoker Invoke);
} // interpreter
#endif // CLANG_EXAMPLE_INTERPRETER_INVOKE_H

cfe/trunk/examples/clang-interpreter/Invoke.cpp

//==-- examples/clang-interpreter/Invoke.cpp - Clang C Interpreter Example -==//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "Invoke.h"
#include <iostream>
#include <stdexcept>
namespace interpreter {
int TryIt(llvm::ExecutionEngine *EE, llvm::Function *EntryFn,
const std::vector<std::string> &Args, char *const *EnvP,
Invoker Invoke) {
int Res = -1;
try {
Res = Invoke(EE, EntryFn, Args, EnvP);
} catch (const std::exception &E) {
std::cout << "Caught '" << E.what() << "'\n";
} catch (...) {
std::cout << "Unknown exception\n";
}
return Res;
}
}

cfe/trunk/examples/clang-interpreter/Manager.h

//===-- examples/clang-interpreter/Manager.h - Clang C Interpreter Example -==//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef CLANG_EXAMPLE_INTERPRETER_MANAGER_H
#define CLANG_EXAMPLE_INTERPRETER_MANAGER_H
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
#if defined(_WIN32) && defined(_WIN64)
#define CLANG_INTERPRETER_COFF_FORMAT
#define CLANG_INTERPRETER_WIN_EXCEPTIONS
#endif
namespace interpreter {
class SingleSectionMemoryManager : public llvm::SectionMemoryManager {
struct Block {
uint8_t *Addr = nullptr, *End = nullptr;
void Reset(uint8_t *Ptr, uintptr_t Size);
uint8_t *Next(uintptr_t Size, unsigned Alignment);
};
Block Code, ROData, RWData;
public:
uint8_t *allocateCodeSection(uintptr_t Size, unsigned Align, unsigned ID,
llvm::StringRef Name) final;
uint8_t *allocateDataSection(uintptr_t Size, unsigned Align, unsigned ID,
llvm::StringRef Name, bool RO) final;
void reserveAllocationSpace(uintptr_t CodeSize, uint32_t CodeAlign,
uintptr_t ROSize, uint32_t ROAlign,
uintptr_t RWSize, uint32_t RWAlign) final;
bool needsToReserveAllocationSpace() override { return true; }
#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS
using llvm::SectionMemoryManager::EHFrameInfos;
SingleSectionMemoryManager();
void deregisterEHFrames() override;
bool finalizeMemory(std::string *ErrMsg) override;
private:
uintptr_t ImageBase = 0;
#endif
};
}
#endif // CLANG_EXAMPLE_INTERPRETER_MANAGER_H

cfe/trunk/examples/clang-interpreter/Manager.cpp

//==-- examples/clang-interpreter/Manager.cpp - Clang C Interpreter Example -=//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "Manager.h"
#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS
#include "llvm/Support/DynamicLibrary.h"
#define WIN32_LEAN_AND_MEAN
#define NOGDI
#define NOMINMAX
#include <windows.h>
#endif
namespace interpreter {
using namespace llvm;
void SingleSectionMemoryManager::Block::Reset(uint8_t *Ptr, uintptr_t Size) {
assert(Ptr != nullptr && "Bad allocation");
Addr = Ptr;
End = Ptr ? Ptr + Size : nullptr;
}
uint8_t *SingleSectionMemoryManager::Block::Next(uintptr_t Size,
unsigned Alignment) {
uintptr_t Out = (uintptr_t)Addr;
// Align the out pointer properly
if (!Alignment)
Alignment = 16;
Out = (Out + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
// RuntimeDyld should have called reserveAllocationSpace with an amount that
// will fit all required alignemnts...but assert on this to make sure.
assert((Out + Size) <= (uintptr_t)End && "Out of bounds");
// Set the next Addr to deliver at the end of this one.
Addr = (uint8_t *)(Out + Size);
return (uint8_t *)Out;
}
uint8_t *SingleSectionMemoryManager::allocateCodeSection(uintptr_t Size,
unsigned Align,
unsigned ID,
StringRef Name) {
return Code.Next(Size, Align);
}
uint8_t *SingleSectionMemoryManager::allocateDataSection(
uintptr_t Size, unsigned Align, unsigned ID, StringRef Name, bool RO) {
return RO ? ROData.Next(Size, Align) : RWData.Next(Size, Align);
}
void SingleSectionMemoryManager::reserveAllocationSpace(
uintptr_t CodeSize, uint32_t CodeAlign, uintptr_t ROSize, uint32_t ROAlign,
uintptr_t RWSize, uint32_t RWAlign) {
// FIXME: Ideally this should be one contiguous block, with Code, ROData,
// and RWData pointing to sub-blocks within, but setting the correct
// permissions for that wouldn't work unless we over-allocated to have each
// Block.Base aligned on a page boundary.
const unsigned SecID = 0;
Code.Reset(SectionMemoryManager::allocateCodeSection(CodeSize, CodeAlign,
SecID, "code"),
CodeSize);
ROData.Reset(SectionMemoryManager::allocateDataSection(ROSize, ROAlign, SecID,
"rodata", true/*RO*/),
ROSize);
RWData.Reset(SectionMemoryManager::allocateDataSection(RWSize, RWAlign, SecID,
"rwdata", false/*RO*/),
RWSize);
#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS
ImageBase =
(uintptr_t)std::min(std::min(Code.Addr, ROData.Addr), RWData.Addr);
#endif
}
#ifdef CLANG_INTERPRETER_WIN_EXCEPTIONS
// Map an "ImageBase" to a range of adresses that can throw.
//
class SEHFrameHandler {
typedef SingleSectionMemoryManager::EHFrameInfos EHFrameInfos;
typedef std::vector<std::pair<DWORD, DWORD>> ImageRanges;
typedef std::map<uintptr_t, ImageRanges> ImageBaseMap;
ImageBaseMap m_Map;
static void MergeRanges(ImageRanges &Ranges);
uintptr_t FindEHFrame(uintptr_t Caller);
public:
static __declspec(noreturn) void __stdcall RaiseSEHException(void *, void *);
void RegisterEHFrames(uintptr_t ImageBase, const EHFrameInfos &Frames,
bool Block = true);
void DeRegisterEHFrames(uintptr_t ImageBase, const EHFrameInfos &Frames);
};
// Merge overlaping ranges for faster searching with throwing PC
void SEHFrameHandler::MergeRanges(ImageRanges &Ranges) {
std::sort(Ranges.begin(), Ranges.end());
ImageRanges Merged;
ImageRanges::iterator It = Ranges.begin();
auto Current = *(It)++;
while (It != Ranges.end()) {
if (Current.second + 1 < It->first) {
Merged.push_back(Current);
Current = *(It);
} else
Current.second = std::max(Current.second, It->second);
++It;
}
Merged.emplace_back(Current);
Ranges.swap(Merged);
}
// Find the "ImageBase" for Caller/PC who is throwing an exception
uintptr_t SEHFrameHandler::FindEHFrame(uintptr_t Caller) {
for (auto &&Itr : m_Map) {
const uintptr_t ImgBase = Itr.first;
for (auto &&Rng : Itr.second) {
if (Caller >= (ImgBase + Rng.first) && Caller <= (ImgBase + Rng.second))
return ImgBase;
}
}
return 0;
}
// Register a range of adresses for a single section that
void SEHFrameHandler::RegisterEHFrames(uintptr_t ImageBase,
const EHFrameInfos &Frames, bool Block) {
if (Frames.empty())
return;
assert(m_Map.find(ImageBase) == m_Map.end());
ImageBaseMap::mapped_type &Ranges = m_Map[ImageBase];
ImageRanges::value_type *BlockRange = nullptr;
if (Block) {
// Merge all unwind adresses into a single contiguous block for faster
// searching later.
Ranges.emplace_back(std::numeric_limits<DWORD>::max(),
std::numeric_limits<DWORD>::min());
BlockRange = &Ranges.back();
}
for (auto &&Frame : Frames) {
assert(m_Map.find(DWORD64(Frame.Addr)) == m_Map.end() &&
"Runtime function should not be a key!");
PRUNTIME_FUNCTION RFunc = reinterpret_cast<PRUNTIME_FUNCTION>(Frame.Addr);
const size_t N = Frame.Size / sizeof(RUNTIME_FUNCTION);
if (BlockRange) {
for (PRUNTIME_FUNCTION It = RFunc, End = RFunc + N; It < End; ++It) {
BlockRange->first = std::min(BlockRange->first, It->BeginAddress);
BlockRange->second = std::max(BlockRange->second, It->EndAddress);
}
} else {
for (PRUNTIME_FUNCTION It = RFunc, End = RFunc + N; It < End; ++It)
Ranges.emplace_back(It->BeginAddress, It->EndAddress);
}
::RtlAddFunctionTable(RFunc, N, ImageBase);
}
if (!Block)
MergeRanges(Ranges); // Initial sort and merge
}
void SEHFrameHandler::DeRegisterEHFrames(uintptr_t ImageBase,
const EHFrameInfos &Frames) {
if (Frames.empty())
return;
auto Itr = m_Map.find(ImageBase);
if (Itr != m_Map.end()) {
// Remove the ImageBase from lookup
m_Map.erase(Itr);
// Unregister all the PRUNTIME_FUNCTIONs
for (auto &&Frame : Frames)
::RtlDeleteFunctionTable(reinterpret_cast<PRUNTIME_FUNCTION>(Frame.Addr));
}
}
// FIXME: Rather than this static and overriding _CxxThrowException via
// DynamicLibrary::AddSymbol, a better route would be to transform the call
// to _CxxThrowException(Arg0, Arg1) -> RaiseSEHException(Arg0, Arg1, this)
// where 'this' is the SingleSectionMemoryManager instance. This could probably
// be done with clang, and definitely possible by injecting an llvm-IR function
// into the module with the name '_CxxThrowException'
//
static SEHFrameHandler sFrameHandler;
void SingleSectionMemoryManager::deregisterEHFrames() {
sFrameHandler.DeRegisterEHFrames(ImageBase, EHFrames);
EHFrameInfos().swap(EHFrames);
}
bool SingleSectionMemoryManager::finalizeMemory(std::string *ErrMsg) {
sFrameHandler.RegisterEHFrames(ImageBase, EHFrames);
ImageBase = 0;
return SectionMemoryManager::finalizeMemory(ErrMsg);
}
SingleSectionMemoryManager::SingleSectionMemoryManager() {
// Override Windows _CxxThrowException to call into our local version that
// can throw to and from the JIT.
sys::DynamicLibrary::AddSymbol(
"_CxxThrowException",
(void *)(uintptr_t)&SEHFrameHandler::RaiseSEHException);
}
// Adapted from VisualStudio/VC/crt/src/vcruntime/throw.cpp
#ifdef _WIN64
#define _EH_RELATIVE_OFFSETS 1
#endif
// The NT Exception # that we use
#define EH_EXCEPTION_NUMBER ('msc' | 0xE0000000)
// The magic # identifying this version
#define EH_MAGIC_NUMBER1 0x19930520
#define EH_PURE_MAGIC_NUMBER1 0x01994000
// Number of parameters in exception record
#define EH_EXCEPTION_PARAMETERS 4
// A generic exception record
struct EHExceptionRecord {
DWORD ExceptionCode;
DWORD ExceptionFlags; // Flags determined by NT
_EXCEPTION_RECORD *ExceptionRecord; // Extra exception record (unused)
void *ExceptionAddress; // Address at which exception occurred
DWORD NumberParameters; // No. of parameters = EH_EXCEPTION_PARAMETERS
struct EHParameters {
DWORD magicNumber; // = EH_MAGIC_NUMBER1
void *pExceptionObject; // Pointer to the actual object thrown
struct ThrowInfo *pThrowInfo; // Description of thrown object
#if _EH_RELATIVE_OFFSETS
DWORD64 pThrowImageBase; // Image base of thrown object
#endif
} params;
};
__declspec(noreturn) void __stdcall
SEHFrameHandler::RaiseSEHException(void *CxxExcept, void *Info) {
uintptr_t Caller;
static_assert(sizeof(Caller) == sizeof(PVOID), "Size mismatch");
USHORT Frames = CaptureStackBackTrace(1, 1, (PVOID *)&Caller, NULL);
assert(Frames && "No frames captured");
(void)Frames;
const DWORD64 BaseAddr = sFrameHandler.FindEHFrame(Caller);
if (BaseAddr == 0)
_CxxThrowException(CxxExcept, (_ThrowInfo *)Info);
// A generic exception record
EHExceptionRecord Exception = {
EH_EXCEPTION_NUMBER, // Exception number
EXCEPTION_NONCONTINUABLE, // Exception flags (we don't do resume)
nullptr, // Additional record (none)
nullptr, // Address of exception (OS fills in)
EH_EXCEPTION_PARAMETERS, // Number of parameters
{EH_MAGIC_NUMBER1, CxxExcept, (struct ThrowInfo *)Info,
#if _EH_RELATIVE_OFFSETS
BaseAddr
#endif
}};
// const ThrowInfo* pTI = (const ThrowInfo*)Info;
#ifdef THROW_ISWINRT
if (pTI && (THROW_ISWINRT((*pTI)))) {
// The pointer to the ExceptionInfo structure is stored sizeof(void*)
// infront of each WinRT Exception Info.
ULONG_PTR *EPtr = *reinterpret_cast<ULONG_PTR **>(CxxExcept);
EPtr--;
WINRTEXCEPTIONINFO **ppWei = reinterpret_cast<WINRTEXCEPTIONINFO **>(EPtr);
pTI = (*ppWei)->throwInfo;
(*ppWei)->PrepareThrow(ppWei);
}
#endif
// If the throw info indicates this throw is from a pure region,
// set the magic number to the Pure one, so only a pure-region
// catch will see it.
//
// Also use the Pure magic number on Win64 if we were unable to
// determine an image base, since that was the old way to determine
// a pure throw, before the TI_IsPure bit was added to the FuncInfo
// attributes field.
if (Info != nullptr) {
#ifdef THROW_ISPURE
if (THROW_ISPURE(*pTI))
Exception.params.magicNumber = EH_PURE_MAGIC_NUMBER1;
#if _EH_RELATIVE_OFFSETS
else
#endif // _EH_RELATIVE_OFFSETS
#endif // THROW_ISPURE
// Not quite sure what this is about, but pThrowImageBase can never be 0
// here, as that is used to mark when an "ImageBase" was not found.
#if 0 && _EH_RELATIVE_OFFSETS
if (Exception.params.pThrowImageBase == 0)
Exception.params.magicNumber = EH_PURE_MAGIC_NUMBER1;
#endif // _EH_RELATIVE_OFFSETS
}
// Hand it off to the OS:
#if defined(_M_X64) && defined(_NTSUBSET_)
RtlRaiseException((PEXCEPTION_RECORD)&Exception);
#else
RaiseException(Exception.ExceptionCode, Exception.ExceptionFlags,
Exception.NumberParameters, (PULONG_PTR)&Exception.params);
#endif
}
#endif // CLANG_INTERPRETER_WIN_EXCEPTIONS
} // namespace interpreter

cfe/trunk/examples/clang-interpreter/main.cpp

//===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===// //===-- examples/clang-interpreter/main.cpp - Clang C Interpreter Example -===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "Invoke.h"
#include "Manager.h"
#include "clang/CodeGen/CodeGenAction.h"
#include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/DiagnosticOptions.h"
#include "clang/CodeGen/CodeGenAction.h"
#include "clang/Driver/Compilation.h" #include "clang/Driver/Compilation.h"
#include "clang/Driver/Driver.h" #include "clang/Driver/Driver.h"
#include "clang/Driver/Tool.h" #include "clang/Driver/Tool.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/CompilerInvocation.h" #include "clang/Frontend/CompilerInvocation.h"
#include "clang/Frontend/FrontendDiagnostic.h" #include "clang/Frontend/FrontendDiagnostic.h"
#include "clang/Frontend/TextDiagnosticPrinter.h" #include "clang/Frontend/TextDiagnosticPrinter.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/MCJIT.h" #include "llvm/ExecutionEngine/Orc/CompileUtils.h"
#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/Host.h" #include "llvm/Support/Host.h"
#include "llvm/Support/ManagedStatic.h" #include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/Path.h" #include "llvm/Support/Path.h"
#include "llvm/Support/TargetSelect.h" #include "llvm/Support/TargetSelect.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"
using namespace clang; using namespace clang;
using namespace clang::driver; using namespace clang::driver;
namespace interpreter {
static llvm::ExecutionEngine *
createExecutionEngine(std::unique_ptr<llvm::Module> M, std::string *ErrorStr) {
llvm::EngineBuilder EB(std::move(M));
EB.setErrorStr(ErrorStr);
EB.setMemoryManager(llvm::make_unique<SingleSectionMemoryManager>());
llvm::ExecutionEngine *EE = EB.create();
EE->finalizeObject();
return EE;
}
// Invoked from a try/catch block in invoke.cpp.
//
static int Invoke(llvm::ExecutionEngine *EE, llvm::Function *EntryFn,
const std::vector<std::string> &Args, char *const *EnvP) {
return EE->runFunctionAsMain(EntryFn, Args, EnvP);
}
// This function isn't referenced outside its translation unit, but it // This function isn't referenced outside its translation unit, but it
// can't use the "static" keyword because its address is used for // can't use the "static" keyword because its address is used for
// GetMainExecutable (since some platforms don't support taking the // GetMainExecutable (since some platforms don't support taking the
// address of main, and some platforms can't implement GetMainExecutable // address of main, and some platforms can't implement GetMainExecutable
// without being given the address of a function in the main executable). // without being given the address of a function in the main executable).
std::string GetExecutablePath(const char *Argv0, void *MainAddr) { std::string GetExecutablePath(const char *Argv0, void *MainAddr) {
return llvm::sys::fs::getMainExecutable(Argv0, MainAddr); return llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
} }
} // namespace interpreter namespace llvm {
namespace orc {
int main(int argc, const char **argv, char * const *envp) { class SimpleJIT {
private:
ExecutionSession ES;
std::shared_ptr<SymbolResolver> Resolver;
std::unique_ptr<TargetMachine> TM;
const DataLayout DL;
RTDyldObjectLinkingLayer ObjectLayer;
IRCompileLayer<decltype(ObjectLayer), SimpleCompiler> CompileLayer;
public:
SimpleJIT()
: Resolver(createLegacyLookupResolver(
ES,
[this](const std::string &Name) -> JITSymbol {
if (auto Sym = CompileLayer.findSymbol(Name, false))
return Sym;
else if (auto Err = Sym.takeError())
return std::move(Err);
if (auto SymAddr =
RTDyldMemoryManager::getSymbolAddressInProcess(Name))
return JITSymbol(SymAddr, JITSymbolFlags::Exported);
return nullptr;
},
[](Error Err) { cantFail(std::move(Err), "lookupFlags failed"); })),
TM(EngineBuilder().selectTarget()), DL(TM->createDataLayout()),
ObjectLayer(ES,
[this](VModuleKey) {
return RTDyldObjectLinkingLayer::Resources{
std::make_shared<SectionMemoryManager>(), Resolver};
}),
CompileLayer(ObjectLayer, SimpleCompiler(*TM)) {
llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
}
const TargetMachine &getTargetMachine() const { return *TM; }
VModuleKey addModule(std::unique_ptr<Module> M) {
// Add the module to the JIT with a new VModuleKey.
auto K = ES.allocateVModule();
cantFail(CompileLayer.addModule(K, std::move(M)));
return K;
}
JITSymbol findSymbol(const StringRef &Name) {
std::string MangledName;
raw_string_ostream MangledNameStream(MangledName);
Mangler::getNameWithPrefix(MangledNameStream, Name, DL);
return CompileLayer.findSymbol(MangledNameStream.str(), true);
}
JITTargetAddress getSymbolAddress(const StringRef &Name) {
return cantFail(findSymbol(Name).getAddress());
}
void removeModule(VModuleKey K) {
cantFail(CompileLayer.removeModule(K));
}
};
} // end namespace orc
} // end namespace llvm
int main(int argc, const char **argv) {
// This just needs to be some symbol in the binary; C++ doesn't // This just needs to be some symbol in the binary; C++ doesn't
// allow taking the address of ::main however. // allow taking the address of ::main however.
void *MainAddr = (void*) (intptr_t) interpreter::GetExecutablePath; void *MainAddr = (void*) (intptr_t) GetExecutablePath;
std::string Path = interpreter::GetExecutablePath(argv[0], MainAddr); std::string Path = GetExecutablePath(argv[0], MainAddr);
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions(); IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
TextDiagnosticPrinter *DiagClient = TextDiagnosticPrinter *DiagClient =
new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts); new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs()); IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient); DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
const std::string TripleStr = llvm::sys::getProcessTriple(); const std::string TripleStr = llvm::sys::getProcessTriple();
llvm::Triple T(TripleStr); llvm::Triple T(TripleStr);
// Use ELF on Windows-32 and MingW for now. // Use ELF on Windows-32 and MingW for now.
#ifndef CLANG_INTERPRETER_COFF_FORMAT #ifndef CLANG_INTERPRETER_COFF_FORMAT
if (T.isOSBinFormatCOFF()) if (T.isOSBinFormatCOFF())
T.setObjectFormat(llvm::Triple::ELF); T.setObjectFormat(llvm::Triple::ELF);
#endif #endif
Driver TheDriver(Path, T.str(), Diags); Driver TheDriver(Path, T.str(), Diags);
TheDriver.setTitle("clang interpreter"); TheDriver.setTitle("clang interpreter");
TheDriver.setCheckInputsExist(false); TheDriver.setCheckInputsExist(false);
// FIXME: This is a hack to try to force the driver to do something we can // FIXME: This is a hack to try to force the driver to do something we can
// recognize. We need to extend the driver library to support this use model // recognize. We need to extend the driver library to support this use model
// (basically, exactly one input, and the operation mode is hard wired). // (basically, exactly one input, and the operation mode is hard wired).
SmallVector<const char *, 16> Args(argv, argv + argc); SmallVector<const char *, 16> Args(argv, argv + argc);
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines#endif
std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction()); std::unique_ptr<CodeGenAction> Act(new EmitLLVMOnlyAction());
if (!Clang.ExecuteAction(*Act)) if (!Clang.ExecuteAction(*Act))
return 1; return 1;
llvm::InitializeNativeTarget(); llvm::InitializeNativeTarget();
llvm::InitializeNativeTargetAsmPrinter(); llvm::InitializeNativeTargetAsmPrinter();
int Res = 255; int Res = 255;
if (std::unique_ptr<llvm::Module> Module = Act->takeModule()) { std::unique_ptr<llvm::Module> Module = Act->takeModule();
llvm::Function *EntryFn = Module->getFunction("main");
if (!EntryFn) {
llvm::errs() << "'main' function not found in module.\n";
return Res;
}
std::string Error;
std::unique_ptr<llvm::ExecutionEngine> EE(
interpreter::createExecutionEngine(std::move(Module), &Error));
if (!EE) {
llvm::errs() << "unable to make execution engine: " << Error << "\n";
return Res;
}
interpreter::InvokeArgs Args; if (Module) {
for (int I = 1; I < argc; ++I) llvm::orc::SimpleJIT J;
Args.push_back(argv[I]); auto H = J.addModule(std::move(Module));
auto Main = (int(*)(...))J.getSymbolAddress("main");
if (Clang.getLangOpts().CPlusPlus) Res = Main();
Res = interpreter::TryIt(EE.get(), EntryFn, Args, envp, interpreter::Invoke); J.removeModule(H);
else
Res = interpreter::Invoke(EE.get(), EntryFn, Args, envp);
} }
// Shutdown. // Shutdown.
llvm::llvm_shutdown(); llvm::llvm_shutdown();
return Res; return Res;
} }
cfe/trunk/examples/clang-interpreter/Invoke.cpp