2002-12-23 23:59:41 +00:00
|
|
|
//===- lli.cpp - LLVM Interpreter / Dynamic compiler ----------------------===//
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:44:31 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-08-23 17:05:04 +00:00
|
|
|
//
|
2003-12-26 05:07:35 +00:00
|
|
|
// This utility provides a simple wrapper around the LLVM Execution Engines,
|
|
|
|
// which allow the direct execution of LLVM programs through a Just-In-Time
|
2009-07-03 12:11:32 +00:00
|
|
|
// compiler, or through an interpreter if no JIT is available for this platform.
|
2001-08-23 17:05:04 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2015-03-25 12:11:48 +00:00
|
|
|
#include "OrcLazyJIT.h"
|
2013-10-04 00:49:38 +00:00
|
|
|
#include "RemoteMemoryManager.h"
|
2012-09-05 16:50:34 +00:00
|
|
|
#include "RemoteTarget.h"
|
2014-01-23 19:57:16 +00:00
|
|
|
#include "RemoteTargetExternal.h"
|
2010-08-28 01:30:02 +00:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2007-05-06 04:58:26 +00:00
|
|
|
#include "llvm/Bitcode/ReaderWriter.h"
|
2006-08-01 22:34:35 +00:00
|
|
|
#include "llvm/CodeGen/LinkAllCodegenComponents.h"
|
2003-09-05 19:42:34 +00:00
|
|
|
#include "llvm/ExecutionEngine/GenericValue.h"
|
2009-06-25 02:04:04 +00:00
|
|
|
#include "llvm/ExecutionEngine/Interpreter.h"
|
|
|
|
#include "llvm/ExecutionEngine/JITEventListener.h"
|
2010-11-17 16:06:43 +00:00
|
|
|
#include "llvm/ExecutionEngine/MCJIT.h"
|
2014-01-08 04:09:09 +00:00
|
|
|
#include "llvm/ExecutionEngine/ObjectCache.h"
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226940 91177308-0d34-0410-b5e6-96231b3b80d8
2015-01-23 21:25:00 +00:00
|
|
|
#include "llvm/ExecutionEngine/OrcMCJITReplacement.h"
|
2012-11-27 19:49:00 +00:00
|
|
|
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
|
2013-10-29 01:29:56 +00:00
|
|
|
#include "llvm/IR/IRBuilder.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
#include "llvm/IR/Type.h"
|
2013-10-29 01:29:56 +00:00
|
|
|
#include "llvm/IR/TypeBuilder.h"
|
2013-03-26 02:25:37 +00:00
|
|
|
#include "llvm/IRReader/IRReader.h"
|
2014-01-08 04:09:09 +00:00
|
|
|
#include "llvm/Object/Archive.h"
|
|
|
|
#include "llvm/Object/ObjectFile.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/DynamicLibrary.h"
|
|
|
|
#include "llvm/Support/Format.h"
|
2006-12-06 01:18:01 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
|
|
|
#include "llvm/Support/Memory.h"
|
2007-05-06 04:58:26 +00:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2015-03-23 18:07:13 +00:00
|
|
|
#include "llvm/Support/Path.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/PluginLoader.h"
|
2009-03-06 05:34:10 +00:00
|
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Process.h"
|
2013-10-02 17:12:36 +00:00
|
|
|
#include "llvm/Support/Program.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Signals.h"
|
2013-03-26 02:25:37 +00:00
|
|
|
#include "llvm/Support/SourceMgr.h"
|
2011-08-24 18:08:43 +00:00
|
|
|
#include "llvm/Support/TargetSelect.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2013-06-28 19:11:40 +00:00
|
|
|
#include "llvm/Transforms/Instrumentation.h"
|
2007-04-27 17:02:33 +00:00
|
|
|
#include <cerrno>
|
2010-10-22 14:53:59 +00:00
|
|
|
|
|
|
|
#ifdef __CYGWIN__
|
|
|
|
#include <cygwin/version.h>
|
|
|
|
#if defined(CYGWIN_VERSION_DLL_MAJOR) && CYGWIN_VERSION_DLL_MAJOR<1007
|
|
|
|
#define DO_NOTHING_ATEXIT 1
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 03:10:36 +00:00
|
|
|
#define DEBUG_TYPE "lli"
|
|
|
|
|
2002-12-23 23:59:41 +00:00
|
|
|
namespace {
|
2015-03-25 12:11:48 +00:00
|
|
|
|
|
|
|
enum class JITKind { MCJIT, OrcMCJITReplacement, OrcLazy };
|
|
|
|
|
2002-12-23 23:59:41 +00:00
|
|
|
cl::opt<std::string>
|
2007-07-05 17:07:56 +00:00
|
|
|
InputFile(cl::desc("<input bitcode>"), cl::Positional, cl::init("-"));
|
2002-07-22 02:10:13 +00:00
|
|
|
|
2002-12-23 23:59:41 +00:00
|
|
|
cl::list<std::string>
|
|
|
|
InputArgv(cl::ConsumeAfter, cl::desc("<program arguments>..."));
|
2002-07-22 02:10:13 +00:00
|
|
|
|
2002-12-23 23:59:41 +00:00
|
|
|
cl::opt<bool> ForceInterpreter("force-interpreter",
|
2003-09-25 18:10:34 +00:00
|
|
|
cl::desc("Force interpretation: disable JIT"),
|
|
|
|
cl::init(false));
|
2008-08-08 08:12:06 +00:00
|
|
|
|
2015-03-25 12:11:48 +00:00
|
|
|
cl::opt<JITKind> UseJITKind("jit-kind",
|
|
|
|
cl::desc("Choose underlying JIT kind."),
|
|
|
|
cl::init(JITKind::MCJIT),
|
|
|
|
cl::values(
|
|
|
|
clEnumValN(JITKind::MCJIT, "mcjit",
|
|
|
|
"MCJIT"),
|
|
|
|
clEnumValN(JITKind::OrcMCJITReplacement,
|
|
|
|
"orc-mcjit",
|
|
|
|
"Orc-based MCJIT replacement"),
|
|
|
|
clEnumValN(JITKind::OrcLazy,
|
|
|
|
"orc-lazy",
|
|
|
|
"Orc-based lazy JIT."),
|
|
|
|
clEnumValEnd));
|
[Orc] New JIT APIs.
This patch adds a new set of JIT APIs to LLVM. The aim of these new APIs is to
cleanly support a wider range of JIT use cases in LLVM, and encourage the
development and contribution of re-usable infrastructure for LLVM JIT use-cases.
These APIs are intended to live alongside the MCJIT APIs, and should not affect
existing clients.
Included in this patch:
1) New headers in include/llvm/ExecutionEngine/Orc that provide a set of
components for building JIT infrastructure.
Implementation code for these headers lives in lib/ExecutionEngine/Orc.
2) A prototype re-implementation of MCJIT (OrcMCJITReplacement) built out of the
new components.
3) Minor changes to RTDyldMemoryManager needed to support the new components.
These changes should not impact existing clients.
4) A new flag for lli, -use-orcmcjit, which will cause lli to use the
OrcMCJITReplacement class as its underlying execution engine, rather than
MCJIT itself.
Tests to follow shortly.
Special thanks to Michael Ilseman, Pete Cooper, David Blaikie, Eric Christopher,
Justin Bogner, and Jim Grosbach for extensive feedback and discussion.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@226940 91177308-0d34-0410-b5e6-96231b3b80d8
2015-01-23 21:25:00 +00:00
|
|
|
|
2012-09-05 16:50:34 +00:00
|
|
|
// The MCJIT supports building for a target address space separate from
|
|
|
|
// the JIT compilation process. Use a forked process and a copying
|
|
|
|
// memory manager with IPC to execute using this functionality.
|
|
|
|
cl::opt<bool> RemoteMCJIT("remote-mcjit",
|
|
|
|
cl::desc("Execute MCJIT'ed code in a separate process."),
|
|
|
|
cl::init(false));
|
|
|
|
|
2013-10-02 17:12:36 +00:00
|
|
|
// Manually specify the child process for remote execution. This overrides
|
|
|
|
// the simulated remote execution that allocates address space for child
|
2013-10-29 01:33:14 +00:00
|
|
|
// execution. The child process will be executed and will communicate with
|
|
|
|
// lli via stdin/stdout pipes.
|
2013-10-02 17:12:36 +00:00
|
|
|
cl::opt<std::string>
|
2014-01-22 21:52:35 +00:00
|
|
|
ChildExecPath("mcjit-remote-process",
|
|
|
|
cl::desc("Specify the filename of the process to launch "
|
|
|
|
"for remote MCJIT execution. If none is specified,"
|
|
|
|
"\n\tremote execution will be simulated in-process."),
|
|
|
|
cl::value_desc("filename"), cl::init(""));
|
2013-10-02 17:12:36 +00:00
|
|
|
|
2009-05-04 23:05:19 +00:00
|
|
|
// Determine optimization level.
|
|
|
|
cl::opt<char>
|
|
|
|
OptLevel("O",
|
|
|
|
cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
|
|
|
|
"(default = '-O2')"),
|
|
|
|
cl::Prefix,
|
|
|
|
cl::ZeroOrMore,
|
|
|
|
cl::init(' '));
|
2008-08-08 08:12:06 +00:00
|
|
|
|
2005-12-16 05:00:21 +00:00
|
|
|
cl::opt<std::string>
|
2005-12-16 05:19:18 +00:00
|
|
|
TargetTriple("mtriple", cl::desc("Override target triple for module"));
|
2008-11-05 23:21:52 +00:00
|
|
|
|
2010-02-05 16:19:36 +00:00
|
|
|
cl::opt<std::string>
|
|
|
|
MArch("march",
|
|
|
|
cl::desc("Architecture to generate assembly for (see --version)"));
|
|
|
|
|
|
|
|
cl::opt<std::string>
|
|
|
|
MCPU("mcpu",
|
|
|
|
cl::desc("Target a specific cpu type (-mcpu=help for details)"),
|
|
|
|
cl::value_desc("cpu-name"),
|
|
|
|
cl::init(""));
|
|
|
|
|
|
|
|
cl::list<std::string>
|
|
|
|
MAttrs("mattr",
|
|
|
|
cl::CommaSeparated,
|
|
|
|
cl::desc("Target specific attributes (-mattr=help for details)"),
|
|
|
|
cl::value_desc("a1,+a2,-a3,..."));
|
|
|
|
|
2008-11-05 23:21:52 +00:00
|
|
|
cl::opt<std::string>
|
|
|
|
EntryFunc("entry-function",
|
|
|
|
cl::desc("Specify the entry function (default = 'main') "
|
|
|
|
"of the executable"),
|
|
|
|
cl::value_desc("function"),
|
|
|
|
cl::init("main"));
|
2012-01-16 08:56:09 +00:00
|
|
|
|
2013-10-04 00:49:38 +00:00
|
|
|
cl::list<std::string>
|
2013-10-28 21:58:15 +00:00
|
|
|
ExtraModules("extra-module",
|
2013-10-04 00:49:38 +00:00
|
|
|
cl::desc("Extra modules to be loaded"),
|
2013-10-28 22:51:25 +00:00
|
|
|
cl::value_desc("input bitcode"));
|
2013-10-04 00:49:38 +00:00
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
cl::list<std::string>
|
|
|
|
ExtraObjects("extra-object",
|
|
|
|
cl::desc("Extra object files to be loaded"),
|
|
|
|
cl::value_desc("input object"));
|
|
|
|
|
|
|
|
cl::list<std::string>
|
|
|
|
ExtraArchives("extra-archive",
|
|
|
|
cl::desc("Extra archive files to be loaded"),
|
|
|
|
cl::value_desc("input archive"));
|
|
|
|
|
|
|
|
cl::opt<bool>
|
|
|
|
EnableCacheManager("enable-cache-manager",
|
2014-01-09 05:24:05 +00:00
|
|
|
cl::desc("Use cache manager to save/load mdoules"),
|
2014-01-08 04:09:09 +00:00
|
|
|
cl::init(false));
|
|
|
|
|
2014-01-09 05:24:05 +00:00
|
|
|
cl::opt<std::string>
|
|
|
|
ObjectCacheDir("object-cache-dir",
|
|
|
|
cl::desc("Directory to store cached object files "
|
|
|
|
"(must be user writable)"),
|
|
|
|
cl::init(""));
|
|
|
|
|
2003-10-28 22:51:44 +00:00
|
|
|
cl::opt<std::string>
|
|
|
|
FakeArgv0("fake-argv0",
|
|
|
|
cl::desc("Override the 'argv[0]' value passed into the executing"
|
|
|
|
" program"), cl::value_desc("executable"));
|
2012-01-16 08:56:09 +00:00
|
|
|
|
2006-09-14 06:17:09 +00:00
|
|
|
cl::opt<bool>
|
|
|
|
DisableCoreFiles("disable-core-files", cl::Hidden,
|
|
|
|
cl::desc("Disable emission of core files if possible"));
|
2008-04-22 06:51:41 +00:00
|
|
|
|
|
|
|
cl::opt<bool>
|
2008-05-21 18:20:21 +00:00
|
|
|
NoLazyCompilation("disable-lazy-compilation",
|
2008-04-22 06:51:41 +00:00
|
|
|
cl::desc("Disable JIT lazy compilation"),
|
|
|
|
cl::init(false));
|
2011-07-19 06:37:02 +00:00
|
|
|
|
|
|
|
cl::opt<Reloc::Model>
|
|
|
|
RelocModel("relocation-model",
|
|
|
|
cl::desc("Choose relocation model"),
|
|
|
|
cl::init(Reloc::Default),
|
|
|
|
cl::values(
|
|
|
|
clEnumValN(Reloc::Default, "default",
|
|
|
|
"Target default relocation model"),
|
|
|
|
clEnumValN(Reloc::Static, "static",
|
|
|
|
"Non-relocatable code"),
|
|
|
|
clEnumValN(Reloc::PIC_, "pic",
|
|
|
|
"Fully relocatable, position independent code"),
|
|
|
|
clEnumValN(Reloc::DynamicNoPIC, "dynamic-no-pic",
|
|
|
|
"Relocatable external references, non-relocatable code"),
|
|
|
|
clEnumValEnd));
|
2011-07-20 07:51:56 +00:00
|
|
|
|
|
|
|
cl::opt<llvm::CodeModel::Model>
|
|
|
|
CMModel("code-model",
|
|
|
|
cl::desc("Choose code model"),
|
|
|
|
cl::init(CodeModel::JITDefault),
|
|
|
|
cl::values(clEnumValN(CodeModel::JITDefault, "default",
|
|
|
|
"Target default JIT code model"),
|
|
|
|
clEnumValN(CodeModel::Small, "small",
|
|
|
|
"Small code model"),
|
|
|
|
clEnumValN(CodeModel::Kernel, "kernel",
|
|
|
|
"Kernel code model"),
|
|
|
|
clEnumValN(CodeModel::Medium, "medium",
|
|
|
|
"Medium code model"),
|
|
|
|
clEnumValN(CodeModel::Large, "large",
|
|
|
|
"Large code model"),
|
|
|
|
clEnumValEnd));
|
|
|
|
|
2012-04-18 08:34:12 +00:00
|
|
|
cl::opt<bool>
|
2012-10-12 09:55:13 +00:00
|
|
|
GenerateSoftFloatCalls("soft-float",
|
|
|
|
cl::desc("Generate software floating point library calls"),
|
|
|
|
cl::init(false));
|
|
|
|
|
|
|
|
cl::opt<llvm::FloatABI::ABIType>
|
|
|
|
FloatABIForCalls("float-abi",
|
|
|
|
cl::desc("Choose float ABI type"),
|
|
|
|
cl::init(FloatABI::Default),
|
|
|
|
cl::values(
|
|
|
|
clEnumValN(FloatABI::Default, "default",
|
|
|
|
"Target default float ABI type"),
|
|
|
|
clEnumValN(FloatABI::Soft, "soft",
|
|
|
|
"Soft float ABI (implied by -soft-float)"),
|
|
|
|
clEnumValN(FloatABI::Hard, "hard",
|
|
|
|
"Hard float ABI (uses FP registers)"),
|
|
|
|
clEnumValEnd));
|
2002-12-23 23:59:41 +00:00
|
|
|
}
|
2001-10-27 08:43:52 +00:00
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Object cache
|
|
|
|
//
|
2014-01-09 05:24:05 +00:00
|
|
|
// This object cache implementation writes cached objects to disk to the
|
|
|
|
// directory specified by CacheDir, using a filename provided in the module
|
|
|
|
// descriptor. The cache tries to load a saved object using that path if the
|
|
|
|
// file exists. CacheDir defaults to "", in which case objects are cached
|
2014-01-10 10:38:28 +00:00
|
|
|
// alongside their originating bitcodes.
|
2014-01-08 04:09:09 +00:00
|
|
|
//
|
|
|
|
class LLIObjectCache : public ObjectCache {
|
|
|
|
public:
|
2014-01-09 05:24:05 +00:00
|
|
|
LLIObjectCache(const std::string& CacheDir) : CacheDir(CacheDir) {
|
|
|
|
// Add trailing '/' to cache dir if necessary.
|
2014-01-09 05:29:59 +00:00
|
|
|
if (!this->CacheDir.empty() &&
|
|
|
|
this->CacheDir[this->CacheDir.size() - 1] != '/')
|
2014-01-10 10:38:28 +00:00
|
|
|
this->CacheDir += '/';
|
2014-01-09 05:24:05 +00:00
|
|
|
}
|
2015-04-11 02:11:45 +00:00
|
|
|
~LLIObjectCache() override {}
|
2014-01-08 04:09:09 +00:00
|
|
|
|
2014-08-19 18:44:46 +00:00
|
|
|
void notifyObjectCompiled(const Module *M, MemoryBufferRef Obj) override {
|
2014-01-08 04:09:09 +00:00
|
|
|
const std::string ModuleID = M->getModuleIdentifier();
|
|
|
|
std::string CacheName;
|
|
|
|
if (!getCacheFilename(ModuleID, CacheName))
|
|
|
|
return;
|
2014-01-10 10:38:34 +00:00
|
|
|
if (!CacheDir.empty()) { // Create user-defined cache dir.
|
|
|
|
SmallString<128> dir(CacheName);
|
|
|
|
sys::path::remove_filename(dir);
|
|
|
|
sys::fs::create_directories(Twine(dir));
|
|
|
|
}
|
2014-08-25 18:16:47 +00:00
|
|
|
std::error_code EC;
|
|
|
|
raw_fd_ostream outfile(CacheName, EC, sys::fs::F_None);
|
2014-08-19 18:44:46 +00:00
|
|
|
outfile.write(Obj.getBufferStart(), Obj.getBufferSize());
|
2014-01-08 04:09:09 +00:00
|
|
|
outfile.close();
|
|
|
|
}
|
|
|
|
|
2014-08-13 18:49:01 +00:00
|
|
|
std::unique_ptr<MemoryBuffer> getObject(const Module* M) override {
|
2014-01-08 04:09:09 +00:00
|
|
|
const std::string ModuleID = M->getModuleIdentifier();
|
|
|
|
std::string CacheName;
|
|
|
|
if (!getCacheFilename(ModuleID, CacheName))
|
2014-04-25 04:24:47 +00:00
|
|
|
return nullptr;
|
2014-01-08 04:09:09 +00:00
|
|
|
// Load the object from the cache filename
|
2014-07-06 17:43:13 +00:00
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> IRObjectBuffer =
|
|
|
|
MemoryBuffer::getFile(CacheName.c_str(), -1, false);
|
2014-01-08 04:09:09 +00:00
|
|
|
// If the file isn't there, that's OK.
|
|
|
|
if (!IRObjectBuffer)
|
2014-04-25 04:24:47 +00:00
|
|
|
return nullptr;
|
2014-01-08 04:09:09 +00:00
|
|
|
// MCJIT will want to write into this buffer, and we don't want that
|
|
|
|
// because the file has probably just been mmapped. Instead we make
|
|
|
|
// a copy. The filed-based buffer will be released when it goes
|
|
|
|
// out of scope.
|
2014-08-27 20:03:13 +00:00
|
|
|
return MemoryBuffer::getMemBufferCopy(IRObjectBuffer.get()->getBuffer());
|
2014-01-08 04:09:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2014-01-09 05:24:05 +00:00
|
|
|
std::string CacheDir;
|
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
bool getCacheFilename(const std::string &ModID, std::string &CacheName) {
|
|
|
|
std::string Prefix("file:");
|
|
|
|
size_t PrefixLength = Prefix.length();
|
|
|
|
if (ModID.substr(0, PrefixLength) != Prefix)
|
|
|
|
return false;
|
2014-01-10 10:38:40 +00:00
|
|
|
std::string CacheSubdir = ModID.substr(PrefixLength);
|
|
|
|
#if defined(_WIN32)
|
|
|
|
// Transform "X:\foo" => "/X\foo" for convenience.
|
|
|
|
if (isalpha(CacheSubdir[0]) && CacheSubdir[1] == ':') {
|
|
|
|
CacheSubdir[1] = CacheSubdir[0];
|
|
|
|
CacheSubdir[0] = '/';
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
CacheName = CacheDir + CacheSubdir;
|
2014-01-08 04:09:09 +00:00
|
|
|
size_t pos = CacheName.rfind('.');
|
|
|
|
CacheName.replace(pos, CacheName.length() - pos, ".o");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-04-25 04:24:47 +00:00
|
|
|
static ExecutionEngine *EE = nullptr;
|
|
|
|
static LLIObjectCache *CacheManager = nullptr;
|
2007-03-03 18:21:44 +00:00
|
|
|
|
|
|
|
static void do_shutdown() {
|
2010-10-22 14:53:59 +00:00
|
|
|
// Cygwin-1.5 invokes DLL's dtors before atexit handler.
|
|
|
|
#ifndef DO_NOTHING_ATEXIT
|
2007-03-03 18:21:44 +00:00
|
|
|
delete EE;
|
2014-01-08 04:09:09 +00:00
|
|
|
if (CacheManager)
|
|
|
|
delete CacheManager;
|
2007-03-03 18:21:44 +00:00
|
|
|
llvm_shutdown();
|
2010-10-22 14:53:59 +00:00
|
|
|
#endif
|
2007-03-03 18:21:44 +00:00
|
|
|
}
|
|
|
|
|
2013-10-29 01:29:56 +00:00
|
|
|
// On Mingw and Cygwin, an external symbol named '__main' is called from the
|
|
|
|
// generated 'main' function to allow static intialization. To avoid linking
|
|
|
|
// problems with remote targets (because lli's remote target support does not
|
|
|
|
// currently handle external linking) we add a secondary module which defines
|
|
|
|
// an empty '__main' function.
|
|
|
|
static void addCygMingExtraModule(ExecutionEngine *EE,
|
|
|
|
LLVMContext &Context,
|
|
|
|
StringRef TargetTripleStr) {
|
|
|
|
IRBuilder<> Builder(Context);
|
|
|
|
Triple TargetTriple(TargetTripleStr);
|
|
|
|
|
|
|
|
// Create a new module.
|
2014-08-19 04:04:25 +00:00
|
|
|
std::unique_ptr<Module> M = make_unique<Module>("CygMingHelper", Context);
|
2013-10-29 01:29:56 +00:00
|
|
|
M->setTargetTriple(TargetTripleStr);
|
|
|
|
|
|
|
|
// Create an empty function named "__main".
|
|
|
|
Function *Result;
|
|
|
|
if (TargetTriple.isArch64Bit()) {
|
|
|
|
Result = Function::Create(
|
|
|
|
TypeBuilder<int64_t(void), false>::get(Context),
|
2014-08-19 04:04:25 +00:00
|
|
|
GlobalValue::ExternalLinkage, "__main", M.get());
|
2013-10-29 01:29:56 +00:00
|
|
|
} else {
|
|
|
|
Result = Function::Create(
|
|
|
|
TypeBuilder<int32_t(void), false>::get(Context),
|
2014-08-19 04:04:25 +00:00
|
|
|
GlobalValue::ExternalLinkage, "__main", M.get());
|
2013-10-29 01:29:56 +00:00
|
|
|
}
|
|
|
|
BasicBlock *BB = BasicBlock::Create(Context, "__main", Result);
|
|
|
|
Builder.SetInsertPoint(BB);
|
|
|
|
Value *ReturnVal;
|
|
|
|
if (TargetTriple.isArch64Bit())
|
|
|
|
ReturnVal = ConstantInt::get(Context, APInt(64, 0));
|
|
|
|
else
|
|
|
|
ReturnVal = ConstantInt::get(Context, APInt(32, 0));
|
|
|
|
Builder.CreateRet(ReturnVal);
|
|
|
|
|
|
|
|
// Add this new module to the ExecutionEngine.
|
2014-08-19 04:04:25 +00:00
|
|
|
EE->addModule(std::move(M));
|
2013-10-29 01:29:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-08-23 17:05:04 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// main Driver function
|
|
|
|
//
|
2003-10-14 21:39:53 +00:00
|
|
|
int main(int argc, char **argv, char * const *envp) {
|
2009-03-06 05:34:10 +00:00
|
|
|
sys::PrintStackTraceOnErrorSignal();
|
|
|
|
PrettyStackTraceProgram X(argc, argv);
|
2012-01-16 08:56:09 +00:00
|
|
|
|
2009-07-15 22:16:10 +00:00
|
|
|
LLVMContext &Context = getGlobalContext();
|
2007-03-03 18:21:44 +00:00
|
|
|
atexit(do_shutdown); // Call llvm_shutdown() on exit.
|
2009-07-16 02:04:54 +00:00
|
|
|
|
|
|
|
// If we have a native target, initialize it to ensure it is linked in and
|
|
|
|
// usable by the JIT.
|
|
|
|
InitializeNativeTarget();
|
2011-03-18 22:48:41 +00:00
|
|
|
InitializeNativeTargetAsmPrinter();
|
2012-11-05 19:06:05 +00:00
|
|
|
InitializeNativeTargetAsmParser();
|
2009-07-16 02:04:54 +00:00
|
|
|
|
2007-05-06 04:58:26 +00:00
|
|
|
cl::ParseCommandLineOptions(argc, argv,
|
2007-10-08 15:45:12 +00:00
|
|
|
"llvm interpreter & dynamic compiler\n");
|
2004-12-30 05:36:08 +00:00
|
|
|
|
2007-05-06 04:58:26 +00:00
|
|
|
// If the user doesn't want core files, disable them.
|
|
|
|
if (DisableCoreFiles)
|
|
|
|
sys::Process::PreventCoreFiles();
|
2012-01-16 08:56:09 +00:00
|
|
|
|
2007-07-05 17:07:56 +00:00
|
|
|
// Load the bitcode...
|
2010-11-13 00:28:01 +00:00
|
|
|
SMDiagnostic Err;
|
2014-08-26 17:29:46 +00:00
|
|
|
std::unique_ptr<Module> Owner = parseIRFile(InputFile, Err, Context);
|
2014-08-19 04:04:25 +00:00
|
|
|
Module *Mod = Owner.get();
|
2010-01-27 20:34:15 +00:00
|
|
|
if (!Mod) {
|
2011-10-16 04:47:35 +00:00
|
|
|
Err.print(argv[0], errs());
|
2010-11-13 00:28:01 +00:00
|
|
|
return 1;
|
2007-05-06 04:58:26 +00:00
|
|
|
}
|
2004-12-30 05:36:08 +00:00
|
|
|
|
2015-03-25 12:11:48 +00:00
|
|
|
if (UseJITKind == JITKind::OrcLazy)
|
|
|
|
return runOrcLazyJIT(std::move(Owner), argc, argv);
|
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
if (EnableCacheManager) {
|
2014-09-02 22:28:02 +00:00
|
|
|
std::string CacheName("file:");
|
|
|
|
CacheName.append(InputFile);
|
|
|
|
Mod->setModuleIdentifier(CacheName);
|
2014-01-08 04:09:09 +00:00
|
|
|
}
|
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
// If not jitting lazily, load the whole bitcode file eagerly too.
|
|
|
|
if (NoLazyCompilation) {
|
2014-06-13 03:07:50 +00:00
|
|
|
if (std::error_code EC = Mod->materializeAllPermanently()) {
|
2010-01-27 20:34:15 +00:00
|
|
|
errs() << argv[0] << ": bitcode didn't read correctly.\n";
|
2014-01-14 23:51:27 +00:00
|
|
|
errs() << "Reason: " << EC.message() << "\n";
|
2010-01-27 20:34:15 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
2008-04-22 06:51:41 +00:00
|
|
|
}
|
2004-12-30 05:36:08 +00:00
|
|
|
|
2014-01-14 23:51:27 +00:00
|
|
|
std::string ErrorMsg;
|
2014-08-19 04:04:25 +00:00
|
|
|
EngineBuilder builder(std::move(Owner));
|
2010-02-05 16:19:36 +00:00
|
|
|
builder.setMArch(MArch);
|
|
|
|
builder.setMCPU(MCPU);
|
|
|
|
builder.setMAttrs(MAttrs);
|
2011-07-19 06:37:02 +00:00
|
|
|
builder.setRelocationModel(RelocModel);
|
2011-07-20 07:51:56 +00:00
|
|
|
builder.setCodeModel(CMModel);
|
2009-07-18 08:07:13 +00:00
|
|
|
builder.setErrorStr(&ErrorMsg);
|
|
|
|
builder.setEngineKind(ForceInterpreter
|
2009-07-18 00:42:18 +00:00
|
|
|
? EngineKind::Interpreter
|
|
|
|
: EngineKind::JIT);
|
2015-03-25 12:11:48 +00:00
|
|
|
builder.setUseOrcMCJITReplacement(UseJITKind == JITKind::OrcMCJITReplacement);
|
2009-07-18 00:42:18 +00:00
|
|
|
|
2007-05-06 04:58:26 +00:00
|
|
|
// If we are supposed to override the target triple, do so now.
|
|
|
|
if (!TargetTriple.empty())
|
2010-08-28 01:30:02 +00:00
|
|
|
Mod->setTargetTriple(Triple::normalize(TargetTriple));
|
2008-04-22 06:51:41 +00:00
|
|
|
|
2012-01-16 08:56:09 +00:00
|
|
|
// Enable MCJIT if desired.
|
2014-04-25 04:24:47 +00:00
|
|
|
RTDyldMemoryManager *RTDyldMM = nullptr;
|
2014-09-02 22:28:02 +00:00
|
|
|
if (!ForceInterpreter) {
|
2012-09-05 16:50:34 +00:00
|
|
|
if (RemoteMCJIT)
|
2013-10-04 00:49:38 +00:00
|
|
|
RTDyldMM = new RemoteMemoryManager();
|
2012-09-05 16:50:34 +00:00
|
|
|
else
|
2013-05-14 19:29:00 +00:00
|
|
|
RTDyldMM = new SectionMemoryManager();
|
2014-12-03 00:51:19 +00:00
|
|
|
|
|
|
|
// Deliberately construct a temp std::unique_ptr to pass in. Do not null out
|
|
|
|
// RTDyldMM: We still use it below, even though we don't own it.
|
|
|
|
builder.setMCJITMemoryManager(
|
|
|
|
std::unique_ptr<RTDyldMemoryManager>(RTDyldMM));
|
2014-09-23 16:56:02 +00:00
|
|
|
} else if (RemoteMCJIT) {
|
|
|
|
errs() << "error: Remote process execution does not work with the "
|
|
|
|
"interpreter.\n";
|
|
|
|
exit(1);
|
2012-01-16 08:56:09 +00:00
|
|
|
}
|
2010-11-17 16:06:37 +00:00
|
|
|
|
2009-05-04 23:05:19 +00:00
|
|
|
CodeGenOpt::Level OLvl = CodeGenOpt::Default;
|
|
|
|
switch (OptLevel) {
|
|
|
|
default:
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << argv[0] << ": invalid optimization level.\n";
|
2009-05-04 23:05:19 +00:00
|
|
|
return 1;
|
|
|
|
case ' ': break;
|
|
|
|
case '0': OLvl = CodeGenOpt::None; break;
|
2009-10-16 21:02:20 +00:00
|
|
|
case '1': OLvl = CodeGenOpt::Less; break;
|
2009-05-04 23:05:19 +00:00
|
|
|
case '2': OLvl = CodeGenOpt::Default; break;
|
|
|
|
case '3': OLvl = CodeGenOpt::Aggressive; break;
|
|
|
|
}
|
2009-07-18 00:42:18 +00:00
|
|
|
builder.setOptLevel(OLvl);
|
|
|
|
|
2012-10-12 09:55:13 +00:00
|
|
|
TargetOptions Options;
|
|
|
|
Options.UseSoftFloat = GenerateSoftFloatCalls;
|
|
|
|
if (FloatABIForCalls != FloatABI::Default)
|
|
|
|
Options.FloatABIType = FloatABIForCalls;
|
|
|
|
if (GenerateSoftFloatCalls)
|
|
|
|
FloatABIForCalls = FloatABI::Soft;
|
|
|
|
|
|
|
|
builder.setTargetOptions(Options);
|
|
|
|
|
2009-07-18 00:42:18 +00:00
|
|
|
EE = builder.create();
|
2009-07-07 18:31:09 +00:00
|
|
|
if (!EE) {
|
|
|
|
if (!ErrorMsg.empty())
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n";
|
2009-07-07 18:31:09 +00:00
|
|
|
else
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << argv[0] << ": unknown error creating EE!\n";
|
2007-05-06 04:58:26 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
2004-12-30 05:36:08 +00:00
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
if (EnableCacheManager) {
|
2014-01-09 05:24:05 +00:00
|
|
|
CacheManager = new LLIObjectCache(ObjectCacheDir);
|
2014-01-08 04:09:09 +00:00
|
|
|
EE->setObjectCache(CacheManager);
|
|
|
|
}
|
|
|
|
|
2013-10-04 00:49:38 +00:00
|
|
|
// Load any additional modules specified on the command line.
|
|
|
|
for (unsigned i = 0, e = ExtraModules.size(); i != e; ++i) {
|
2014-08-26 17:29:46 +00:00
|
|
|
std::unique_ptr<Module> XMod = parseIRFile(ExtraModules[i], Err, Context);
|
2013-10-04 00:49:38 +00:00
|
|
|
if (!XMod) {
|
|
|
|
Err.print(argv[0], errs());
|
|
|
|
return 1;
|
|
|
|
}
|
2014-01-08 04:09:09 +00:00
|
|
|
if (EnableCacheManager) {
|
2014-09-02 22:28:02 +00:00
|
|
|
std::string CacheName("file:");
|
|
|
|
CacheName.append(ExtraModules[i]);
|
|
|
|
XMod->setModuleIdentifier(CacheName);
|
2014-01-08 04:09:09 +00:00
|
|
|
}
|
2014-08-19 04:04:25 +00:00
|
|
|
EE->addModule(std::move(XMod));
|
2013-10-04 00:49:38 +00:00
|
|
|
}
|
|
|
|
|
2014-01-08 04:09:09 +00:00
|
|
|
for (unsigned i = 0, e = ExtraObjects.size(); i != e; ++i) {
|
2014-08-19 18:44:46 +00:00
|
|
|
ErrorOr<object::OwningBinary<object::ObjectFile>> Obj =
|
2014-01-22 00:14:49 +00:00
|
|
|
object::ObjectFile::createObjectFile(ExtraObjects[i]);
|
2014-01-08 04:09:09 +00:00
|
|
|
if (!Obj) {
|
|
|
|
Err.print(argv[0], errs());
|
|
|
|
return 1;
|
|
|
|
}
|
2014-08-20 15:19:37 +00:00
|
|
|
object::OwningBinary<object::ObjectFile> &O = Obj.get();
|
2014-08-26 21:04:04 +00:00
|
|
|
EE->addObjectFile(std::move(O));
|
2014-01-08 04:09:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = ExtraArchives.size(); i != e; ++i) {
|
2014-08-19 18:44:46 +00:00
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> ArBufOrErr =
|
2014-07-06 17:43:13 +00:00
|
|
|
MemoryBuffer::getFileOrSTDIN(ExtraArchives[i]);
|
2014-08-19 18:44:46 +00:00
|
|
|
if (!ArBufOrErr) {
|
2014-01-08 04:09:09 +00:00
|
|
|
Err.print(argv[0], errs());
|
|
|
|
return 1;
|
|
|
|
}
|
2014-08-19 18:44:46 +00:00
|
|
|
std::unique_ptr<MemoryBuffer> &ArBuf = ArBufOrErr.get();
|
2014-08-01 18:31:17 +00:00
|
|
|
|
|
|
|
ErrorOr<std::unique_ptr<object::Archive>> ArOrErr =
|
2014-08-19 18:44:46 +00:00
|
|
|
object::Archive::create(ArBuf->getMemBufferRef());
|
2014-08-01 18:31:17 +00:00
|
|
|
if (std::error_code EC = ArOrErr.getError()) {
|
|
|
|
errs() << EC.message();
|
2014-01-08 04:09:09 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2014-08-19 18:44:46 +00:00
|
|
|
std::unique_ptr<object::Archive> &Ar = ArOrErr.get();
|
|
|
|
|
|
|
|
object::OwningBinary<object::Archive> OB(std::move(Ar), std::move(ArBuf));
|
|
|
|
|
|
|
|
EE->addArchive(std::move(OB));
|
2014-01-08 04:09:09 +00:00
|
|
|
}
|
|
|
|
|
2013-10-29 01:29:56 +00:00
|
|
|
// If the target is Cygwin/MingW and we are generating remote code, we
|
|
|
|
// need an extra module to help out with linking.
|
|
|
|
if (RemoteMCJIT && Triple(Mod->getTargetTriple()).isOSCygMing()) {
|
|
|
|
addCygMingExtraModule(EE, Context, Mod->getTargetTriple());
|
|
|
|
}
|
|
|
|
|
2012-03-13 08:33:15 +00:00
|
|
|
// The following functions have no effect if their respective profiling
|
|
|
|
// support wasn't enabled in the build configuration.
|
|
|
|
EE->RegisterJITEventListener(
|
|
|
|
JITEventListener::createOProfileJITEventListener());
|
|
|
|
EE->RegisterJITEventListener(
|
|
|
|
JITEventListener::createIntelJITEventListener());
|
2009-06-25 02:04:04 +00:00
|
|
|
|
2012-09-05 16:50:34 +00:00
|
|
|
if (!NoLazyCompilation && RemoteMCJIT) {
|
|
|
|
errs() << "warning: remote mcjit does not support lazy compilation\n";
|
|
|
|
NoLazyCompilation = true;
|
|
|
|
}
|
2009-10-27 22:39:42 +00:00
|
|
|
EE->DisableLazyCompilation(NoLazyCompilation);
|
2008-04-22 06:51:41 +00:00
|
|
|
|
2007-05-06 04:58:26 +00:00
|
|
|
// If the user specifically requested an argv[0] to pass into the program,
|
|
|
|
// do it now.
|
|
|
|
if (!FakeArgv0.empty()) {
|
2015-01-22 01:49:59 +00:00
|
|
|
InputFile = static_cast<std::string>(FakeArgv0);
|
2007-05-06 04:58:26 +00:00
|
|
|
} else {
|
|
|
|
// Otherwise, if there is a .bc suffix on the executable strip it off, it
|
|
|
|
// might confuse the program.
|
2010-04-15 11:33:14 +00:00
|
|
|
if (StringRef(InputFile).endswith(".bc"))
|
2007-05-06 04:58:26 +00:00
|
|
|
InputFile.erase(InputFile.length() - 3);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Add the module's name to the start of the vector of arguments to main().
|
|
|
|
InputArgv.insert(InputArgv.begin(), InputFile);
|
|
|
|
|
|
|
|
// Call the main function from M as if its signature were:
|
|
|
|
// int main (int argc, char **argv, const char **envp)
|
|
|
|
// using the contents of Args to determine argc & argv, and the contents of
|
|
|
|
// EnvVars to determine envp.
|
|
|
|
//
|
2008-11-05 23:21:52 +00:00
|
|
|
Function *EntryFn = Mod->getFunction(EntryFunc);
|
|
|
|
if (!EntryFn) {
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << '\'' << EntryFunc << "\' function not found in module.\n";
|
2007-05-06 04:58:26 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Reset errno to zero on entry to main.
|
|
|
|
errno = 0;
|
2012-01-16 08:56:09 +00:00
|
|
|
|
2013-10-02 18:04:40 +00:00
|
|
|
int Result;
|
|
|
|
|
2012-11-27 19:49:00 +00:00
|
|
|
if (!RemoteMCJIT) {
|
2013-10-11 22:47:10 +00:00
|
|
|
// If the program doesn't explicitly call exit, we will need the Exit
|
|
|
|
// function later on to make an explicit call, so get the function now.
|
|
|
|
Constant *Exit = Mod->getOrInsertFunction("exit", Type::getVoidTy(Context),
|
|
|
|
Type::getInt32Ty(Context),
|
2015-02-26 01:10:49 +00:00
|
|
|
nullptr);
|
2013-10-11 22:47:10 +00:00
|
|
|
|
2013-10-02 18:04:40 +00:00
|
|
|
// Run static constructors.
|
2014-09-02 22:28:02 +00:00
|
|
|
if (!ForceInterpreter) {
|
2013-10-01 01:47:35 +00:00
|
|
|
// Give MCJIT a chance to apply relocations and set page permissions.
|
|
|
|
EE->finalizeObject();
|
|
|
|
}
|
|
|
|
EE->runStaticConstructorsDestructors(false);
|
2008-04-22 06:51:41 +00:00
|
|
|
|
2013-12-07 11:21:42 +00:00
|
|
|
// Trigger compilation separately so code regions that need to be
|
2013-10-02 18:04:40 +00:00
|
|
|
// invalidated will be known.
|
|
|
|
(void)EE->getPointerToFunction(EntryFn);
|
|
|
|
// Clear instruction cache before code will be executed.
|
|
|
|
if (RTDyldMM)
|
|
|
|
static_cast<SectionMemoryManager*>(RTDyldMM)->invalidateInstructionCache();
|
|
|
|
|
|
|
|
// Run main.
|
|
|
|
Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp);
|
|
|
|
|
|
|
|
// Run static destructors.
|
|
|
|
EE->runStaticConstructorsDestructors(true);
|
|
|
|
|
|
|
|
// If the program didn't call exit explicitly, we should call it now.
|
|
|
|
// This ensures that any atexit handlers get called correctly.
|
|
|
|
if (Function *ExitF = dyn_cast<Function>(Exit)) {
|
|
|
|
std::vector<GenericValue> Args;
|
|
|
|
GenericValue ResultGV;
|
|
|
|
ResultGV.IntVal = APInt(32, Result);
|
|
|
|
Args.push_back(ResultGV);
|
|
|
|
EE->runFunction(ExitF, Args);
|
|
|
|
errs() << "ERROR: exit(" << Result << ") returned!\n";
|
|
|
|
abort();
|
|
|
|
} else {
|
|
|
|
errs() << "ERROR: exit defined with wrong prototype!\n";
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// else == "if (RemoteMCJIT)"
|
|
|
|
|
|
|
|
// Remote target MCJIT doesn't (yet) support static constructors. No reason
|
|
|
|
// it couldn't. This is a limitation of the LLI implemantation, not the
|
|
|
|
// MCJIT itself. FIXME.
|
|
|
|
//
|
2013-10-04 00:49:38 +00:00
|
|
|
RemoteMemoryManager *MM = static_cast<RemoteMemoryManager*>(RTDyldMM);
|
2012-09-05 16:50:34 +00:00
|
|
|
// Everything is prepared now, so lay out our program for the target
|
|
|
|
// address space, assign the section addresses to resolve any relocations,
|
|
|
|
// and send it to the target.
|
2013-10-02 17:12:36 +00:00
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<RemoteTarget> Target;
|
2014-01-22 21:52:35 +00:00
|
|
|
if (!ChildExecPath.empty()) { // Remote execution on a child process
|
2014-01-23 19:57:16 +00:00
|
|
|
#ifndef LLVM_ON_UNIX
|
|
|
|
// FIXME: Remove this pointless fallback mode which causes tests to "pass"
|
|
|
|
// on platforms where they should XFAIL.
|
|
|
|
errs() << "Warning: host does not support external remote targets.\n"
|
|
|
|
<< " Defaulting to simulated remote execution\n";
|
|
|
|
Target.reset(new RemoteTarget);
|
|
|
|
#else
|
|
|
|
if (!sys::fs::can_execute(ChildExecPath)) {
|
|
|
|
errs() << "Unable to find usable child executable: '" << ChildExecPath
|
|
|
|
<< "'\n";
|
|
|
|
return -1;
|
2013-10-02 17:12:36 +00:00
|
|
|
}
|
2014-01-23 19:57:16 +00:00
|
|
|
Target.reset(new RemoteTargetExternal(ChildExecPath));
|
|
|
|
#endif
|
2013-10-02 17:12:36 +00:00
|
|
|
} else {
|
|
|
|
// No child process name provided, use simulated remote execution.
|
2014-01-23 19:57:16 +00:00
|
|
|
Target.reset(new RemoteTarget);
|
2013-10-02 17:12:36 +00:00
|
|
|
}
|
|
|
|
|
2013-10-04 00:49:38 +00:00
|
|
|
// Give the memory manager a pointer to our remote target interface object.
|
|
|
|
MM->setRemoteTarget(Target.get());
|
|
|
|
|
|
|
|
// Create the remote target.
|
2014-01-14 22:43:43 +00:00
|
|
|
if (!Target->create()) {
|
|
|
|
errs() << "ERROR: " << Target->getErrorMsg() << "\n";
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
2012-09-05 16:50:34 +00:00
|
|
|
|
|
|
|
// Since we're executing in a (at least simulated) remote address space,
|
|
|
|
// we can't use the ExecutionEngine::runFunctionAsMain(). We have to
|
|
|
|
// grab the function address directly here and tell the remote target
|
|
|
|
// to execute the function.
|
2013-10-04 00:49:38 +00:00
|
|
|
//
|
|
|
|
// Our memory manager will map generated code into the remote address
|
|
|
|
// space as it is loaded and copy the bits over during the finalizeMemory
|
|
|
|
// operation.
|
|
|
|
//
|
2012-09-05 16:50:34 +00:00
|
|
|
// FIXME: argv and envp handling.
|
2013-10-02 17:12:36 +00:00
|
|
|
uint64_t Entry = EE->getFunctionAddress(EntryFn->getName().str());
|
2012-09-05 16:50:34 +00:00
|
|
|
|
2013-05-19 09:55:06 +00:00
|
|
|
DEBUG(dbgs() << "Executing '" << EntryFn->getName() << "' at 0x"
|
|
|
|
<< format("%llx", Entry) << "\n");
|
2012-09-05 16:50:34 +00:00
|
|
|
|
2014-01-14 22:43:43 +00:00
|
|
|
if (!Target->executeCode(Entry, Result))
|
2013-10-02 17:12:36 +00:00
|
|
|
errs() << "ERROR: " << Target->getErrorMsg() << "\n";
|
2012-09-05 16:50:34 +00:00
|
|
|
|
2013-10-02 18:04:40 +00:00
|
|
|
// Like static constructors, the remote target MCJIT support doesn't handle
|
|
|
|
// this yet. It could. FIXME.
|
2007-05-06 04:58:26 +00:00
|
|
|
|
2013-10-02 18:04:40 +00:00
|
|
|
// Stop the remote target
|
|
|
|
Target->stop();
|
2012-09-05 16:50:34 +00:00
|
|
|
}
|
2012-01-16 08:56:09 +00:00
|
|
|
|
2012-09-05 16:50:34 +00:00
|
|
|
return Result;
|
2001-08-23 17:05:04 +00:00
|
|
|
}
|