2012-12-10 17:44:02 -06:00
|
|
|
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
2011-03-15 16:57:26 -05:00
|
|
|
//
|
2012-12-10 17:44:02 -06:00
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
2011-10-21 19:35:52 -05:00
|
|
|
//===----------------------------------------------------------------------===
|
2011-03-15 16:57:26 -05:00
|
|
|
//
|
|
|
|
// This file defines alternate interfaces to core functions that are more
|
|
|
|
// readily callable by Rust's FFI.
|
|
|
|
//
|
2011-10-21 19:35:52 -05:00
|
|
|
//===----------------------------------------------------------------------===
|
2011-03-15 16:57:26 -05:00
|
|
|
|
2013-04-01 15:55:49 -05:00
|
|
|
#include "llvm/IR/InlineAsm.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2011-05-04 23:27:00 -05:00
|
|
|
#include "llvm/Linker.h"
|
2011-04-15 16:35:46 -05:00
|
|
|
#include "llvm/PassManager.h"
|
2013-03-20 06:24:39 -05:00
|
|
|
#include "llvm/IR/InlineAsm.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2012-08-27 20:39:34 -05:00
|
|
|
#include "llvm/Analysis/Verifier.h"
|
|
|
|
#include "llvm/Analysis/Passes.h"
|
2011-04-15 16:35:46 -05:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2012-09-11 01:05:51 -05:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
2011-11-26 00:00:43 -06:00
|
|
|
#include "llvm/Assembly/Parser.h"
|
2011-11-07 07:32:13 -06:00
|
|
|
#include "llvm/Assembly/PrintModulePass.h"
|
2013-03-14 01:40:05 -05:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2011-04-15 16:35:46 -05:00
|
|
|
#include "llvm/Support/FormattedStream.h"
|
2011-05-10 18:10:08 -05:00
|
|
|
#include "llvm/Support/Timer.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2011-08-28 13:58:10 -05:00
|
|
|
#include "llvm/Support/TargetSelect.h"
|
|
|
|
#include "llvm/Support/TargetRegistry.h"
|
2011-11-26 00:00:43 -06:00
|
|
|
#include "llvm/Support/SourceMgr.h"
|
2011-05-06 08:59:33 -05:00
|
|
|
#include "llvm/Support/Host.h"
|
2012-07-25 14:06:03 -05:00
|
|
|
#include "llvm/Support/Debug.h"
|
2012-08-24 23:54:30 -05:00
|
|
|
#include "llvm/Support/DynamicLibrary.h"
|
2012-08-26 07:40:21 -05:00
|
|
|
#include "llvm/Support/Memory.h"
|
2012-08-24 23:54:30 -05:00
|
|
|
#include "llvm/ExecutionEngine/ExecutionEngine.h"
|
|
|
|
#include "llvm/ExecutionEngine/JIT.h"
|
2012-08-26 07:40:21 -05:00
|
|
|
#include "llvm/ExecutionEngine/JITMemoryManager.h"
|
|
|
|
#include "llvm/ExecutionEngine/MCJIT.h"
|
2012-08-24 23:54:30 -05:00
|
|
|
#include "llvm/ExecutionEngine/Interpreter.h"
|
2013-03-20 06:24:39 -05:00
|
|
|
#include "llvm/Target/TargetMachine.h"
|
|
|
|
#include "llvm/Target/TargetOptions.h"
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
|
|
|
#include "llvm/Transforms/IPO.h"
|
2011-03-15 16:57:26 -05:00
|
|
|
#include "llvm-c/Core.h"
|
2011-05-05 13:34:15 -05:00
|
|
|
#include "llvm-c/BitReader.h"
|
2011-03-15 16:57:26 -05:00
|
|
|
#include "llvm-c/Object.h"
|
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
// Used by RustMCJITMemoryManager::getPointerToNamedFunction()
|
|
|
|
// to get around glibc issues. See the function for more information.
|
|
|
|
#ifdef __linux__
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
|
2011-04-15 16:35:46 -05:00
|
|
|
using namespace llvm;
|
2012-09-11 01:05:51 -05:00
|
|
|
using namespace llvm::sys;
|
2011-04-15 16:35:46 -05:00
|
|
|
|
2011-05-04 23:27:00 -05:00
|
|
|
static const char *LLVMRustError;
|
2011-03-15 16:57:26 -05:00
|
|
|
|
2013-04-05 19:17:49 -05:00
|
|
|
extern cl::opt<bool> EnableARMEHABI;
|
|
|
|
|
2011-03-15 16:57:26 -05:00
|
|
|
extern "C" LLVMMemoryBufferRef
|
|
|
|
LLVMRustCreateMemoryBufferWithContentsOfFile(const char *Path) {
|
|
|
|
LLVMMemoryBufferRef MemBuf = NULL;
|
2011-05-04 23:27:00 -05:00
|
|
|
LLVMCreateMemoryBufferWithContentsOfFile(Path, &MemBuf,
|
|
|
|
const_cast<char **>(&LLVMRustError));
|
2011-03-15 16:57:26 -05:00
|
|
|
return MemBuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" const char *LLVMRustGetLastError(void) {
|
|
|
|
return LLVMRustError;
|
|
|
|
}
|
|
|
|
|
2011-04-13 12:53:19 -05:00
|
|
|
extern "C" void LLVMAddBasicAliasAnalysisPass(LLVMPassManagerRef PM);
|
2011-04-18 09:02:34 -05:00
|
|
|
|
2011-11-07 07:32:13 -06:00
|
|
|
extern "C" void LLVMRustAddPrintModulePass(LLVMPassManagerRef PMR,
|
|
|
|
LLVMModuleRef M,
|
|
|
|
const char* path) {
|
|
|
|
PassManager *PM = unwrap<PassManager>(PMR);
|
|
|
|
std::string ErrorInfo;
|
|
|
|
raw_fd_ostream OS(path, ErrorInfo, raw_fd_ostream::F_Binary);
|
|
|
|
formatted_raw_ostream FOS(OS);
|
|
|
|
PM->add(createPrintModulePass(&FOS));
|
|
|
|
PM->run(*unwrap(M));
|
|
|
|
}
|
|
|
|
|
2012-07-21 02:20:45 -05:00
|
|
|
void LLVMInitializeX86TargetInfo();
|
|
|
|
void LLVMInitializeX86Target();
|
|
|
|
void LLVMInitializeX86TargetMC();
|
|
|
|
void LLVMInitializeX86AsmPrinter();
|
|
|
|
void LLVMInitializeX86AsmParser();
|
|
|
|
|
2012-11-29 18:21:49 -06:00
|
|
|
|
|
|
|
void LLVMInitializeARMTargetInfo();
|
|
|
|
void LLVMInitializeARMTarget();
|
|
|
|
void LLVMInitializeARMTargetMC();
|
|
|
|
void LLVMInitializeARMAsmPrinter();
|
|
|
|
void LLVMInitializeARMAsmParser();
|
2013-01-29 08:28:08 -06:00
|
|
|
|
|
|
|
void LLVMInitializeMipsTargetInfo();
|
|
|
|
void LLVMInitializeMipsTarget();
|
|
|
|
void LLVMInitializeMipsTargetMC();
|
|
|
|
void LLVMInitializeMipsAsmPrinter();
|
|
|
|
void LLVMInitializeMipsAsmParser();
|
2012-08-24 23:54:30 -05:00
|
|
|
// Only initialize the platforms supported by Rust here,
|
|
|
|
// because using --llvm-root will have multiple platforms
|
|
|
|
// that rustllvm doesn't actually link to and it's pointless to put target info
|
|
|
|
// into the registry that Rust can not generate machine code for.
|
|
|
|
|
2012-08-29 00:49:35 -05:00
|
|
|
void LLVMRustInitializeTargets() {
|
|
|
|
LLVMInitializeX86TargetInfo();
|
|
|
|
LLVMInitializeX86Target();
|
|
|
|
LLVMInitializeX86TargetMC();
|
|
|
|
LLVMInitializeX86AsmPrinter();
|
|
|
|
LLVMInitializeX86AsmParser();
|
2013-05-03 18:25:04 -05:00
|
|
|
|
2012-11-29 18:21:49 -06:00
|
|
|
LLVMInitializeARMTargetInfo();
|
|
|
|
LLVMInitializeARMTarget();
|
|
|
|
LLVMInitializeARMTargetMC();
|
|
|
|
LLVMInitializeARMAsmPrinter();
|
2013-05-03 18:25:04 -05:00
|
|
|
LLVMInitializeARMAsmParser();
|
2013-01-29 08:28:08 -06:00
|
|
|
|
|
|
|
LLVMInitializeMipsTargetInfo();
|
|
|
|
LLVMInitializeMipsTarget();
|
|
|
|
LLVMInitializeMipsTargetMC();
|
|
|
|
LLVMInitializeMipsAsmPrinter();
|
2013-05-03 18:25:04 -05:00
|
|
|
LLVMInitializeMipsAsmParser();
|
2012-08-29 00:49:35 -05:00
|
|
|
}
|
2012-08-24 23:54:30 -05:00
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
// Custom memory manager for MCJITting. It needs special features
|
|
|
|
// that the generic JIT memory manager doesn't entail. Based on
|
|
|
|
// code from LLI, change where needed for Rust.
|
|
|
|
class RustMCJITMemoryManager : public JITMemoryManager {
|
|
|
|
public:
|
|
|
|
SmallVector<sys::MemoryBlock, 16> AllocatedDataMem;
|
|
|
|
SmallVector<sys::MemoryBlock, 16> AllocatedCodeMem;
|
|
|
|
SmallVector<sys::MemoryBlock, 16> FreeCodeMem;
|
2012-08-29 00:49:35 -05:00
|
|
|
void* __morestack;
|
2012-09-11 01:05:51 -05:00
|
|
|
DenseSet<DynamicLibrary*> crates;
|
2012-08-26 07:40:21 -05:00
|
|
|
|
2012-08-29 00:49:35 -05:00
|
|
|
RustMCJITMemoryManager(void* sym) : __morestack(sym) { }
|
2012-08-26 07:40:21 -05:00
|
|
|
~RustMCJITMemoryManager();
|
|
|
|
|
2012-09-11 01:05:51 -05:00
|
|
|
bool loadCrate(const char*, std::string*);
|
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
virtual uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
|
|
|
|
unsigned SectionID);
|
|
|
|
|
|
|
|
virtual uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
|
2013-04-01 15:55:49 -05:00
|
|
|
unsigned SectionID, bool isReadOnly);
|
|
|
|
|
|
|
|
virtual bool applyPermissions(std::string *Str);
|
2012-08-26 07:40:21 -05:00
|
|
|
|
|
|
|
virtual void *getPointerToNamedFunction(const std::string &Name,
|
|
|
|
bool AbortOnFailure = true);
|
|
|
|
|
|
|
|
// Invalidate instruction cache for code sections. Some platforms with
|
|
|
|
// separate data cache and instruction cache require explicit cache flush,
|
|
|
|
// otherwise JIT code manipulations (like resolved relocations) will get to
|
|
|
|
// the data cache but not to the instruction cache.
|
|
|
|
virtual void invalidateInstructionCache();
|
|
|
|
|
|
|
|
// The MCJITMemoryManager doesn't use the following functions, so we don't
|
|
|
|
// need implement them.
|
|
|
|
virtual void setMemoryWritable() {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
virtual void setMemoryExecutable() {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
virtual void setPoisonMemory(bool poison) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
virtual void AllocateGOT() {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
virtual uint8_t *getGOTBase() const {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
virtual uint8_t *startFunctionBody(const Function *F,
|
|
|
|
uintptr_t &ActualSize){
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
|
|
|
|
unsigned Alignment) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart,
|
|
|
|
uint8_t *FunctionEnd) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
virtual uint8_t *allocateGlobal(uintptr_t Size, unsigned Alignment) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
virtual void deallocateFunctionBody(void *Body) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
virtual uint8_t* startExceptionTable(const Function* F,
|
|
|
|
uintptr_t &ActualSize) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
|
|
|
|
uint8_t *TableEnd, uint8_t* FrameRegister) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
virtual void deallocateExceptionTable(void *ET) {
|
|
|
|
llvm_unreachable("Unimplemented call");
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-09-11 01:05:51 -05:00
|
|
|
bool RustMCJITMemoryManager::loadCrate(const char* file, std::string* err) {
|
|
|
|
DynamicLibrary crate = DynamicLibrary::getPermanentLibrary(file,
|
|
|
|
err);
|
|
|
|
|
|
|
|
if(crate.isValid()) {
|
|
|
|
crates.insert(&crate);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
uint8_t *RustMCJITMemoryManager::allocateDataSection(uintptr_t Size,
|
2013-04-01 15:55:49 -05:00
|
|
|
unsigned Alignment,
|
|
|
|
unsigned SectionID,
|
|
|
|
bool isReadOnly) {
|
2012-08-26 07:40:21 -05:00
|
|
|
if (!Alignment)
|
|
|
|
Alignment = 16;
|
|
|
|
uint8_t *Addr = (uint8_t*)calloc((Size + Alignment - 1)/Alignment, Alignment);
|
|
|
|
AllocatedDataMem.push_back(sys::MemoryBlock(Addr, Size));
|
|
|
|
return Addr;
|
|
|
|
}
|
|
|
|
|
2013-04-01 15:55:49 -05:00
|
|
|
bool RustMCJITMemoryManager::applyPermissions(std::string *Str) {
|
|
|
|
// Empty.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
uint8_t *RustMCJITMemoryManager::allocateCodeSection(uintptr_t Size,
|
2013-04-01 15:55:49 -05:00
|
|
|
unsigned Alignment,
|
|
|
|
unsigned SectionID) {
|
2012-08-26 07:40:21 -05:00
|
|
|
if (!Alignment)
|
|
|
|
Alignment = 16;
|
|
|
|
unsigned NeedAllocate = Alignment * ((Size + Alignment - 1)/Alignment + 1);
|
|
|
|
uintptr_t Addr = 0;
|
|
|
|
// Look in the list of free code memory regions and use a block there if one
|
|
|
|
// is available.
|
|
|
|
for (int i = 0, e = FreeCodeMem.size(); i != e; ++i) {
|
|
|
|
sys::MemoryBlock &MB = FreeCodeMem[i];
|
|
|
|
if (MB.size() >= NeedAllocate) {
|
|
|
|
Addr = (uintptr_t)MB.base();
|
|
|
|
uintptr_t EndOfBlock = Addr + MB.size();
|
|
|
|
// Align the address.
|
|
|
|
Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
|
|
|
|
// Store cutted free memory block.
|
|
|
|
FreeCodeMem[i] = sys::MemoryBlock((void*)(Addr + Size),
|
|
|
|
EndOfBlock - Addr - Size);
|
|
|
|
return (uint8_t*)Addr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// No pre-allocated free block was large enough. Allocate a new memory region.
|
|
|
|
sys::MemoryBlock MB = sys::Memory::AllocateRWX(NeedAllocate, 0, 0);
|
|
|
|
|
|
|
|
AllocatedCodeMem.push_back(MB);
|
|
|
|
Addr = (uintptr_t)MB.base();
|
|
|
|
uintptr_t EndOfBlock = Addr + MB.size();
|
|
|
|
// Align the address.
|
|
|
|
Addr = (Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1);
|
|
|
|
// The AllocateRWX may allocate much more memory than we need. In this case,
|
|
|
|
// we store the unused memory as a free memory block.
|
|
|
|
unsigned FreeSize = EndOfBlock-Addr-Size;
|
|
|
|
if (FreeSize > 16)
|
|
|
|
FreeCodeMem.push_back(sys::MemoryBlock((void*)(Addr + Size), FreeSize));
|
|
|
|
|
|
|
|
// Return aligned address
|
|
|
|
return (uint8_t*)Addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void RustMCJITMemoryManager::invalidateInstructionCache() {
|
|
|
|
for (int i = 0, e = AllocatedCodeMem.size(); i != e; ++i)
|
|
|
|
sys::Memory::InvalidateInstructionCache(AllocatedCodeMem[i].base(),
|
|
|
|
AllocatedCodeMem[i].size());
|
|
|
|
}
|
|
|
|
|
|
|
|
void *RustMCJITMemoryManager::getPointerToNamedFunction(const std::string &Name,
|
|
|
|
bool AbortOnFailure) {
|
|
|
|
#ifdef __linux__
|
|
|
|
// Force the following functions to be linked in to anything that uses the
|
|
|
|
// JIT. This is a hack designed to work around the all-too-clever Glibc
|
|
|
|
// strategy of making these functions work differently when inlined vs. when
|
|
|
|
// not inlined, and hiding their real definitions in a separate archive file
|
|
|
|
// that the dynamic linker can't see. For more info, search for
|
|
|
|
// 'libc_nonshared.a' on Google, or read http://llvm.org/PR274.
|
|
|
|
if (Name == "stat") return (void*)(intptr_t)&stat;
|
|
|
|
if (Name == "fstat") return (void*)(intptr_t)&fstat;
|
|
|
|
if (Name == "lstat") return (void*)(intptr_t)&lstat;
|
|
|
|
if (Name == "stat64") return (void*)(intptr_t)&stat64;
|
|
|
|
if (Name == "fstat64") return (void*)(intptr_t)&fstat64;
|
|
|
|
if (Name == "lstat64") return (void*)(intptr_t)&lstat64;
|
|
|
|
if (Name == "atexit") return (void*)(intptr_t)&atexit;
|
|
|
|
if (Name == "mknod") return (void*)(intptr_t)&mknod;
|
|
|
|
#endif
|
|
|
|
|
2012-12-27 16:17:32 -06:00
|
|
|
if (Name == "__morestack" || Name == "___morestack") return &__morestack;
|
2012-08-27 18:51:30 -05:00
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
const char *NameStr = Name.c_str();
|
2012-09-11 01:05:51 -05:00
|
|
|
|
2012-09-28 03:05:49 -05:00
|
|
|
// Look through loaded crates and main for symbols.
|
2012-09-11 01:05:51 -05:00
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
void *Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(NameStr);
|
|
|
|
if (Ptr) return Ptr;
|
|
|
|
|
2012-12-22 15:24:19 -06:00
|
|
|
// If it wasn't found and if it starts with an underscore ('_') character,
|
|
|
|
// try again without the underscore.
|
|
|
|
if (NameStr[0] == '_') {
|
|
|
|
Ptr = sys::DynamicLibrary::SearchForAddressOfSymbol(NameStr+1);
|
|
|
|
if (Ptr) return Ptr;
|
|
|
|
}
|
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
if (AbortOnFailure)
|
|
|
|
report_fatal_error("Program used external function '" + Name +
|
|
|
|
"' which could not be resolved!");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
RustMCJITMemoryManager::~RustMCJITMemoryManager() {
|
|
|
|
for (unsigned i = 0, e = AllocatedCodeMem.size(); i != e; ++i)
|
|
|
|
sys::Memory::ReleaseRWX(AllocatedCodeMem[i]);
|
|
|
|
for (unsigned i = 0, e = AllocatedDataMem.size(); i != e; ++i)
|
|
|
|
free(AllocatedDataMem[i].base());
|
|
|
|
}
|
|
|
|
|
2012-08-29 00:49:35 -05:00
|
|
|
extern "C" void*
|
2012-09-11 01:05:51 -05:00
|
|
|
LLVMRustPrepareJIT(void* __morestack) {
|
|
|
|
// An execution engine will take ownership of this later
|
|
|
|
// and clean it up for us.
|
|
|
|
|
|
|
|
return (void*) new RustMCJITMemoryManager(__morestack);
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" bool
|
|
|
|
LLVMRustLoadCrate(void* mem, const char* crate) {
|
|
|
|
RustMCJITMemoryManager* manager = (RustMCJITMemoryManager*) mem;
|
|
|
|
std::string Err;
|
|
|
|
|
|
|
|
assert(manager);
|
|
|
|
|
|
|
|
if(!manager->loadCrate(crate, &Err)) {
|
|
|
|
LLVMRustError = Err.c_str();
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void*
|
|
|
|
LLVMRustExecuteJIT(void* mem,
|
|
|
|
LLVMPassManagerRef PMR,
|
|
|
|
LLVMModuleRef M,
|
|
|
|
CodeGenOpt::Level OptLevel,
|
|
|
|
bool EnableSegmentedStacks) {
|
2012-08-24 23:54:30 -05:00
|
|
|
|
|
|
|
InitializeNativeTarget();
|
|
|
|
InitializeNativeTargetAsmPrinter();
|
2012-09-27 01:07:33 -05:00
|
|
|
InitializeNativeTargetAsmParser();
|
2012-08-24 23:54:30 -05:00
|
|
|
|
|
|
|
std::string Err;
|
|
|
|
TargetOptions Options;
|
2012-09-26 21:57:19 -05:00
|
|
|
Options.JITExceptionHandling = true;
|
2012-08-26 07:40:21 -05:00
|
|
|
Options.JITEmitDebugInfo = true;
|
2012-08-27 18:51:30 -05:00
|
|
|
Options.NoFramePointerElim = true;
|
|
|
|
Options.EnableSegmentedStacks = EnableSegmentedStacks;
|
2012-08-27 20:39:34 -05:00
|
|
|
PassManager *PM = unwrap<PassManager>(PMR);
|
2012-09-11 01:05:51 -05:00
|
|
|
RustMCJITMemoryManager* MM = (RustMCJITMemoryManager*) mem;
|
|
|
|
|
|
|
|
assert(MM);
|
2012-08-24 23:54:30 -05:00
|
|
|
|
2012-08-27 20:39:34 -05:00
|
|
|
PM->add(createBasicAliasAnalysisPass());
|
|
|
|
PM->add(createInstructionCombiningPass());
|
|
|
|
PM->add(createReassociatePass());
|
|
|
|
PM->add(createGVNPass());
|
|
|
|
PM->add(createCFGSimplificationPass());
|
|
|
|
PM->add(createFunctionInliningPass());
|
2012-08-29 00:49:35 -05:00
|
|
|
PM->add(createPromoteMemoryToRegisterPass());
|
2012-08-27 20:39:34 -05:00
|
|
|
PM->run(*unwrap(M));
|
2012-08-24 23:54:30 -05:00
|
|
|
|
2012-08-29 00:49:35 -05:00
|
|
|
ExecutionEngine* EE = EngineBuilder(unwrap(M))
|
2012-09-28 03:05:49 -05:00
|
|
|
.setErrorStr(&Err)
|
2012-08-24 23:54:30 -05:00
|
|
|
.setTargetOptions(Options)
|
2012-08-26 07:40:21 -05:00
|
|
|
.setJITMemoryManager(MM)
|
2012-08-24 23:54:30 -05:00
|
|
|
.setOptLevel(OptLevel)
|
|
|
|
.setUseMCJIT(true)
|
2012-08-29 00:49:35 -05:00
|
|
|
.setAllocateGVsWithCode(false)
|
2012-08-24 23:54:30 -05:00
|
|
|
.create();
|
|
|
|
|
|
|
|
if(!EE || Err != "") {
|
|
|
|
LLVMRustError = Err.c_str();
|
2012-08-29 00:49:35 -05:00
|
|
|
return 0;
|
2012-08-24 23:54:30 -05:00
|
|
|
}
|
|
|
|
|
2012-08-26 07:40:21 -05:00
|
|
|
MM->invalidateInstructionCache();
|
2012-08-29 00:49:35 -05:00
|
|
|
Function* func = EE->FindFunctionNamed("_rust_main");
|
2012-08-24 23:54:30 -05:00
|
|
|
|
|
|
|
if(!func || Err != "") {
|
|
|
|
LLVMRustError = Err.c_str();
|
2012-08-29 00:49:35 -05:00
|
|
|
return 0;
|
2012-08-24 23:54:30 -05:00
|
|
|
}
|
|
|
|
|
2012-08-29 00:49:35 -05:00
|
|
|
void* entry = EE->getPointerToFunction(func);
|
2012-08-26 07:40:21 -05:00
|
|
|
assert(entry);
|
2012-08-24 23:54:30 -05:00
|
|
|
|
2012-08-29 00:49:35 -05:00
|
|
|
return entry;
|
2012-08-24 23:54:30 -05:00
|
|
|
}
|
|
|
|
|
2012-07-13 16:06:30 -05:00
|
|
|
extern "C" bool
|
2011-10-21 19:35:52 -05:00
|
|
|
LLVMRustWriteOutputFile(LLVMPassManagerRef PMR,
|
|
|
|
LLVMModuleRef M,
|
|
|
|
const char *triple,
|
2013-04-22 06:54:12 -05:00
|
|
|
const char *feature,
|
2011-10-21 19:35:52 -05:00
|
|
|
const char *path,
|
|
|
|
TargetMachine::CodeGenFileType FileType,
|
2011-11-27 00:38:36 -06:00
|
|
|
CodeGenOpt::Level OptLevel,
|
2013-05-03 18:25:04 -05:00
|
|
|
bool EnableSegmentedStacks) {
|
2011-04-26 17:21:20 -05:00
|
|
|
|
2012-08-29 00:49:35 -05:00
|
|
|
LLVMRustInitializeTargets();
|
2011-11-27 00:38:36 -06:00
|
|
|
|
2013-04-05 19:17:49 -05:00
|
|
|
// Initializing the command-line options more than once is not
|
|
|
|
// allowed. So, check if they've already been initialized.
|
|
|
|
// (This could happen if we're being called from rustpkg, for
|
|
|
|
// example.)
|
|
|
|
if (!EnableARMEHABI) {
|
|
|
|
int argc = 3;
|
|
|
|
const char* argv[] = {"rustc", "-arm-enable-ehabi",
|
2013-05-03 18:25:04 -05:00
|
|
|
"-arm-enable-ehabi-descriptors"};
|
2013-04-05 19:17:49 -05:00
|
|
|
cl::ParseCommandLineOptions(argc, argv);
|
|
|
|
}
|
2013-03-14 01:40:05 -05:00
|
|
|
|
2011-11-27 00:38:36 -06:00
|
|
|
TargetOptions Options;
|
|
|
|
Options.NoFramePointerElim = true;
|
|
|
|
Options.EnableSegmentedStacks = EnableSegmentedStacks;
|
2013-03-29 18:55:04 -05:00
|
|
|
Options.FixedStackSegmentSize = 2 * 1024 * 1024; // XXX: This is too big.
|
2011-11-27 00:38:36 -06:00
|
|
|
|
2013-03-28 18:47:33 -05:00
|
|
|
PassManager *PM = unwrap<PassManager>(PMR);
|
|
|
|
|
2011-04-15 16:35:46 -05:00
|
|
|
std::string Err;
|
2013-03-13 06:50:49 -05:00
|
|
|
std::string Trip(Triple::normalize(triple));
|
2013-04-22 06:54:12 -05:00
|
|
|
std::string FeaturesStr(feature);
|
2012-04-30 17:40:04 -05:00
|
|
|
std::string CPUStr("generic");
|
2013-03-13 06:50:49 -05:00
|
|
|
const Target *TheTarget = TargetRegistry::lookupTarget(Trip, Err);
|
2011-07-25 10:11:24 -05:00
|
|
|
TargetMachine *Target =
|
2011-11-27 00:38:36 -06:00
|
|
|
TheTarget->createTargetMachine(Trip, CPUStr, FeaturesStr,
|
2013-05-03 18:25:04 -05:00
|
|
|
Options, Reloc::PIC_,
|
|
|
|
CodeModel::Default, OptLevel);
|
2013-03-28 18:47:33 -05:00
|
|
|
Target->addAnalysisPasses(*PM);
|
|
|
|
|
2011-04-15 16:35:46 -05:00
|
|
|
bool NoVerify = false;
|
|
|
|
std::string ErrorInfo;
|
|
|
|
raw_fd_ostream OS(path, ErrorInfo,
|
|
|
|
raw_fd_ostream::F_Binary);
|
2012-07-13 16:06:30 -05:00
|
|
|
if (ErrorInfo != "") {
|
|
|
|
LLVMRustError = ErrorInfo.c_str();
|
|
|
|
return false;
|
|
|
|
}
|
2011-04-15 16:35:46 -05:00
|
|
|
formatted_raw_ostream FOS(OS);
|
2011-04-18 09:02:34 -05:00
|
|
|
|
2011-11-27 00:38:36 -06:00
|
|
|
bool foo = Target->addPassesToEmitFile(*PM, FOS, FileType, NoVerify);
|
2011-04-15 16:35:46 -05:00
|
|
|
assert(!foo);
|
2011-04-22 11:01:45 -05:00
|
|
|
(void)foo;
|
2011-04-15 16:35:46 -05:00
|
|
|
PM->run(*unwrap(M));
|
2011-05-13 23:48:51 -05:00
|
|
|
delete Target;
|
2012-07-13 16:06:30 -05:00
|
|
|
return true;
|
2011-04-15 16:35:46 -05:00
|
|
|
}
|
2011-05-05 13:34:15 -05:00
|
|
|
|
2011-11-26 00:00:43 -06:00
|
|
|
extern "C" LLVMModuleRef LLVMRustParseAssemblyFile(const char *Filename) {
|
|
|
|
SMDiagnostic d;
|
|
|
|
Module *m = ParseAssemblyFile(Filename, d, getGlobalContext());
|
|
|
|
if (m) {
|
|
|
|
return wrap(m);
|
|
|
|
} else {
|
2013-04-01 15:55:49 -05:00
|
|
|
LLVMRustError = d.getMessage().str().c_str();
|
2011-11-26 00:00:43 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-05 13:34:15 -05:00
|
|
|
extern "C" LLVMModuleRef LLVMRustParseBitcode(LLVMMemoryBufferRef MemBuf) {
|
|
|
|
LLVMModuleRef M;
|
|
|
|
return LLVMParseBitcode(MemBuf, &M, const_cast<char **>(&LLVMRustError))
|
|
|
|
? NULL : M;
|
|
|
|
}
|
|
|
|
|
2011-05-07 13:54:23 -05:00
|
|
|
extern "C" LLVMValueRef LLVMRustConstSmallInt(LLVMTypeRef IntTy, unsigned N,
|
|
|
|
LLVMBool SignExtend) {
|
|
|
|
return LLVMConstInt(IntTy, (unsigned long long)N, SignExtend);
|
|
|
|
}
|
2011-05-10 18:10:08 -05:00
|
|
|
|
2013-05-03 18:25:04 -05:00
|
|
|
extern "C" LLVMValueRef LLVMRustConstInt(LLVMTypeRef IntTy,
|
|
|
|
unsigned N_hi,
|
|
|
|
unsigned N_lo,
|
|
|
|
LLVMBool SignExtend) {
|
2011-11-16 14:15:54 -06:00
|
|
|
unsigned long long N = N_hi;
|
|
|
|
N <<= 32;
|
|
|
|
N |= N_lo;
|
|
|
|
return LLVMConstInt(IntTy, N, SignExtend);
|
|
|
|
}
|
|
|
|
|
2011-05-10 18:10:08 -05:00
|
|
|
extern bool llvm::TimePassesIsEnabled;
|
|
|
|
extern "C" void LLVMRustEnableTimePasses() {
|
|
|
|
TimePassesIsEnabled = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" void LLVMRustPrintPassTimings() {
|
|
|
|
raw_fd_ostream OS (2, false); // stderr.
|
|
|
|
TimerGroup::printAll(OS);
|
|
|
|
}
|
2011-10-31 16:42:17 -05:00
|
|
|
|
2011-11-14 10:32:31 -06:00
|
|
|
extern "C" LLVMValueRef LLVMGetOrInsertFunction(LLVMModuleRef M,
|
|
|
|
const char* Name,
|
|
|
|
LLVMTypeRef FunctionTy) {
|
|
|
|
return wrap(unwrap(M)->getOrInsertFunction(Name,
|
|
|
|
unwrap<FunctionType>(FunctionTy)));
|
|
|
|
}
|
2011-11-09 23:55:09 -06:00
|
|
|
|
|
|
|
extern "C" LLVMTypeRef LLVMMetadataTypeInContext(LLVMContextRef C) {
|
|
|
|
return wrap(Type::getMetadataTy(*unwrap(C)));
|
|
|
|
}
|
|
|
|
extern "C" LLVMTypeRef LLVMMetadataType(void) {
|
|
|
|
return LLVMMetadataTypeInContext(LLVMGetGlobalContext());
|
|
|
|
}
|
2012-06-21 17:01:32 -05:00
|
|
|
|
2013-05-12 14:22:20 -05:00
|
|
|
extern "C" LLVMValueRef LLVMBuildAtomicLoad(LLVMBuilderRef B,
|
|
|
|
LLVMValueRef source,
|
|
|
|
const char* Name,
|
2013-05-20 19:28:06 -05:00
|
|
|
AtomicOrdering order,
|
|
|
|
unsigned alignment) {
|
2013-05-12 14:22:20 -05:00
|
|
|
LoadInst* li = new LoadInst(unwrap(source),0);
|
|
|
|
li->setVolatile(true);
|
|
|
|
li->setAtomic(order);
|
2013-05-20 19:28:06 -05:00
|
|
|
li->setAlignment(alignment);
|
2013-05-16 21:48:24 -05:00
|
|
|
return wrap(unwrap(B)->Insert(li, Name));
|
2013-05-12 14:22:20 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
extern "C" LLVMValueRef LLVMBuildAtomicStore(LLVMBuilderRef B,
|
2013-05-20 19:28:06 -05:00
|
|
|
LLVMValueRef val,
|
|
|
|
LLVMValueRef target,
|
|
|
|
AtomicOrdering order,
|
|
|
|
unsigned alignment) {
|
2013-05-12 14:22:20 -05:00
|
|
|
StoreInst* si = new StoreInst(unwrap(val),unwrap(target));
|
|
|
|
si->setVolatile(true);
|
|
|
|
si->setAtomic(order);
|
2013-05-20 19:28:06 -05:00
|
|
|
si->setAlignment(alignment);
|
2013-05-12 14:22:20 -05:00
|
|
|
return wrap(unwrap(B)->Insert(si));
|
|
|
|
}
|
|
|
|
|
2012-10-21 21:23:50 -05:00
|
|
|
extern "C" LLVMValueRef LLVMBuildAtomicCmpXchg(LLVMBuilderRef B,
|
|
|
|
LLVMValueRef target,
|
|
|
|
LLVMValueRef old,
|
|
|
|
LLVMValueRef source,
|
|
|
|
AtomicOrdering order) {
|
|
|
|
return wrap(unwrap(B)->CreateAtomicCmpXchg(unwrap(target), unwrap(old),
|
|
|
|
unwrap(source), order));
|
|
|
|
}
|
2012-06-21 17:01:32 -05:00
|
|
|
extern "C" LLVMValueRef LLVMBuildAtomicRMW(LLVMBuilderRef B,
|
|
|
|
AtomicRMWInst::BinOp op,
|
|
|
|
LLVMValueRef target,
|
|
|
|
LLVMValueRef source,
|
|
|
|
AtomicOrdering order) {
|
|
|
|
return wrap(unwrap(B)->CreateAtomicRMW(op,
|
|
|
|
unwrap(target), unwrap(source),
|
|
|
|
order));
|
|
|
|
}
|
2012-07-25 14:06:03 -05:00
|
|
|
|
|
|
|
extern "C" void LLVMSetDebug(int Enabled) {
|
2012-10-08 14:40:09 -05:00
|
|
|
#ifndef NDEBUG
|
2012-07-25 14:06:03 -05:00
|
|
|
DebugFlag = Enabled;
|
2012-10-08 14:40:09 -05:00
|
|
|
#endif
|
2012-07-25 14:06:03 -05:00
|
|
|
}
|
2013-03-10 00:37:50 -06:00
|
|
|
|
|
|
|
extern "C" LLVMValueRef LLVMInlineAsm(LLVMTypeRef Ty,
|
|
|
|
char *AsmString,
|
|
|
|
char *Constraints,
|
|
|
|
LLVMBool HasSideEffects,
|
2013-03-10 03:38:29 -05:00
|
|
|
LLVMBool IsAlignStack,
|
2013-03-08 19:44:37 -06:00
|
|
|
unsigned Dialect) {
|
2013-03-10 00:37:50 -06:00
|
|
|
return wrap(InlineAsm::get(unwrap<FunctionType>(Ty), AsmString,
|
|
|
|
Constraints, HasSideEffects,
|
2013-03-08 19:44:37 -06:00
|
|
|
IsAlignStack, (InlineAsm::AsmDialect) Dialect));
|
2013-03-10 00:37:50 -06:00
|
|
|
}
|