int main()
{
InitializeNativeTarget();
llvm_start_multithreaded();
LLVMContext context;
string error;
OwningPtr<llvm::MemoryBuffer> fileBuf;
MemoryBuffer::getFile("hw.bc", fileBuf);
ErrorOr<Module*> m = parseBitcodeFile(fileBuf.get(), context);
ExecutionEngine *ee = ExecutionEngine::create(m.get());
Function* func = ee->FindFunctionNamed("main");
std::cout << "hop " << m.get() << " ee " << ee << " f " << func << std::endl;
typedef void (*PFN)();
PFN pfn = reinterpret_cast<PFN>(ee->getPointerToFunction(func));
pfn();
Function* f = ee->FindFunctionNamed("fib");
std::cout << "big " << f << std::endl;
// typedef std::function<int(int)> fibType;
typedef int (*fibType)(int);
fibType ffib = reinterpret_cast<fibType>(ee->getPointerToFunction(f));
std::cout << "fib " << ffib(7) << std::endl;
delete ee;
}
int main()
{
TestClass tc;
tc.setHealth(100);
tc.printHealth();
InitializeNativeTarget();
LLVMContext context;
string error;
auto mb = MemoryBuffer::getFile("bitcode/damage.bc");
if (!mb) {
cout << "ERROR: Failed to getFile" << endl;
return 0;
}
auto m = parseBitcodeFile(mb->get(), context);
if(!m) {
cout << "ERROR: Failed to load script file." << endl;
return 0;
}
ExecutionEngine *ee = ExecutionEngine::create(m.get());
// NOTE: Function names are mangled by the compiler.
Function* init_func = ee->FindFunctionNamed("_Z9initilizev");
if(!init_func) {
cout << "ERROR: Failed to find 'initilize' function." << endl;
return 0;
}
Function* attack_func = ee->FindFunctionNamed("_Z6attackP9TestClass");
if(!attack_func) {
cout << "ERROR: Failed to find 'attack' function." << endl;
return 0;
}
typedef void (*init_pfn)();
init_pfn initilize = reinterpret_cast<init_pfn>(ee->getPointerToFunction(init_func));
if(!initilize) {
cout << "ERROR: Failed to cast 'initilize' function." << endl;
return 0;
}
initilize();
cout << "Running attacking script..." << endl;
typedef void (*attack_pfn)(TestClass*);
attack_pfn attack = reinterpret_cast<attack_pfn>(ee->getPointerToFunction(attack_func));
if(!attack) {
cout << "ERROR: Failed to cast 'attack' function." << endl;
return 0;
}
attack(&tc);
tc.printHealth();
delete ee;
}
int main(int argc, char **argv)
{
using namespace llvm;
std::cout << "hello_world_ir: " << std::endl;
std::cout << std::endl;
std::cout << hello_world_ir << std::endl;
std::cout << std::endl;
InitializeNativeTarget();
LLVMContext context;
SMDiagnostic error;
Module *m = ParseIR(MemoryBuffer::getMemBuffer(StringRef(hello_world_ir)), error, context);
if(!m)
{
error.print(argv[0], errs());
}
ExecutionEngine *ee = ExecutionEngine::create(m);
Function *func = ee->FindFunctionNamed("hello_world");
typedef void (*fcn_ptr)();
fcn_ptr hello_world = reinterpret_cast<fcn_ptr>(ee->getPointerToFunction(func));
hello_world();
delete ee;
return 0;
}
int main(int argc, char **argv) {
int n = argc > 1 ? atol(argv[1]) : 10;
InitializeNativeTarget();
LLVMContext Context;
Module *M = new Module("test", Context);
ExecutionEngine* EE = llvm::EngineBuilder(M).setEngineKind(EngineKind::JIT).create();
for (int i = 0; i < n; ++i) {
SMDiagnostic error;
ParseAssemblyString(function_assembly,
M,
error,
Context);
Function *func = M->getFunction( "factorial" );
typedef int(*func_t)(int);
func_t f = (func_t)(uintptr_t)(EE->getPointerToFunction(func));
EE->freeMachineCodeForFunction(func);
func->eraseFromParent();
}
delete EE;
llvm_shutdown();
return 0;
}
casefoldFunctionType caseFoldCodeGen(void) {
Module * M = new Module("casefold", getGlobalContext());
IDISA::IDISA_Builder * idb = GetIDISA_Builder(M);
kernel::PipelineBuilder pipelineBuilder(M, idb);
Encoding encoding(Encoding::Type::UTF_8, 8);
pablo::PabloFunction * function = casefold2pablo(encoding);
pipelineBuilder.CreateKernels(function);
pipelineBuilder.ExecuteKernels();
//std::cerr << "ExecuteKernels(); done\n";
llvm::Function * main_IR = M->getFunction("Main");
ExecutionEngine * mEngine = JIT_to_ExecutionEngine(M);
mEngine->finalizeObject();
//std::cerr << "finalizeObject(); done\n";
delete idb;
return reinterpret_cast<casefoldFunctionType>(mEngine->getPointerToFunction(main_IR));
}
void* getPointerToFunction(Module * mod, Function * func)
{
ExecutionEngine * execEngine = createExecutionEngine(mod);
if (!execEngine) exit(-1);
return execEngine->getPointerToFunction(func);
}
extern "C" void*
LLVMRustExecuteJIT(void* mem,
LLVMPassManagerRef PMR,
LLVMModuleRef M,
CodeGenOpt::Level OptLevel,
bool EnableSegmentedStacks) {
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
InitializeNativeTargetAsmParser();
std::string Err;
TargetOptions Options;
Options.JITExceptionHandling = true;
Options.JITEmitDebugInfo = true;
Options.NoFramePointerElim = true;
Options.EnableSegmentedStacks = EnableSegmentedStacks;
PassManager *PM = unwrap<PassManager>(PMR);
RustMCJITMemoryManager* MM = (RustMCJITMemoryManager*) mem;
assert(MM);
PM->add(createBasicAliasAnalysisPass());
PM->add(createInstructionCombiningPass());
PM->add(createReassociatePass());
PM->add(createGVNPass());
PM->add(createCFGSimplificationPass());
PM->add(createFunctionInliningPass());
PM->add(createPromoteMemoryToRegisterPass());
PM->run(*unwrap(M));
ExecutionEngine* EE = EngineBuilder(unwrap(M))
.setErrorStr(&Err)
.setTargetOptions(Options)
.setJITMemoryManager(MM)
.setOptLevel(OptLevel)
.setUseMCJIT(true)
.setAllocateGVsWithCode(false)
.create();
if(!EE || Err != "") {
LLVMRustError = Err.c_str();
return 0;
}
MM->invalidateInstructionCache();
Function* func = EE->FindFunctionNamed("_rust_main");
if(!func || Err != "") {
LLVMRustError = Err.c_str();
return 0;
}
void* entry = EE->getPointerToFunction(func);
assert(entry);
return entry;
}
void * compile(llvm::Module * m) {
ExecutionEngine * engine =
EngineBuilder(std::unique_ptr<Module>(m))
.create();
engine->finalizeObject();
return engine->getPointerToFunction(
m->getFunction("aFun"));
}
int
main (int argc, char const *argv[])
{
Module* mod = makeLLVMModule();
verifyModule(*mod, PrintMessageAction);
ExecutionEngine* jit = ExecutionEngine::create(mod);
Function* factorial = mod->getFunction("factorial");
int (*native_factorial)(int) = (int (*)(int)) jit->getPointerToFunction(factorial);
int arg1 = argc > 1 ? atoi(argv[1]) : 1;
printf("Factorial(%d) = %d.\n", arg1, native_factorial(arg1));
return 0;
}
void* getPointerToFunction(Module* mod, std::string functionName) {
ExecutionEngine *execEngine = createExecutionEngine(mod);
if (!execEngine) exit(-1);
Function* f = mod->getFunction(functionName);
if (!f) {
errs() << "Error: Function '" << functionName << "' not found in module "
<< mod->getModuleIdentifier() << "!\n";
exit(-1);
}
return execEngine->getPointerToFunction(f);
}
Ret(*compile(const pegsolitaire::ast::Function<Ret, Types...> & function))(Types...) {
using namespace llvm;
Module * module = new Module("compiledModule", getGlobalContext());
IRBuilder<> builder(getGlobalContext());
pegsolitaire::codegen::CodeGenerator cg(module, builder);
auto f = cg(function);
#ifndef NDEBUG
module->dump();
#endif
ExecutionEngine * executionEngine = EngineBuilder(module).create();
// TODO we actually need a mapping from Types... to NativeTypes... here:
return reinterpret_cast<Ret(*)(Types...)>(executionEngine->getPointerToFunction(f));
}
main_func_type jit_engine::compile(const ast::Program &prog) {
llvm::LLVMContext &c=llvm::getGlobalContext();
llvm::Module *m=new llvm::Module("brainfuck", c);
brainfuck::codegen(*m, prog);
//m->dump();
std::string ErrStr;
ExecutionEngine *TheExecutionEngine = EngineBuilder(m).setErrorStr(&ErrStr).create();
if (!TheExecutionEngine) {
fprintf(stderr, "Could not create ExecutionEngine: %s\n", ErrStr.c_str());
exit(1);
}
Function *f_main=m->getFunction("main");
// Optimize, target dependant
if(optimization_level_>0)
{
FunctionPassManager OurFPM(m);
// Set up the optimizer pipeline. Start with registering info about how the
// target lays out data structures.
OurFPM.add(new TargetData(*TheExecutionEngine->getTargetData()));
// Provide basic AliasAnalysis support for GVN.
OurFPM.add(createBasicAliasAnalysisPass());
// Do simple "peephole" optimizations and bit-twiddling optzns.
OurFPM.add(createInstructionCombiningPass());
// Reassociate expressions.
OurFPM.add(createReassociatePass());
// Eliminate Common SubExpressions.
OurFPM.add(createGVNPass());
// Simplify the control flow graph (deleting unreachable blocks, etc).
OurFPM.add(createCFGSimplificationPass());
//OurFPM.add(createLoopSimplifyPass());
//OurFPM.add(createBlockPlacementPass());
//OurFPM.add(createConstantPropagationPass());
OurFPM.doInitialization();
OurFPM.run(*f_main);
}
//m->dump();
void *rp=TheExecutionEngine->getPointerToFunction(f_main);
main_func_type fp=reinterpret_cast<main_func_type>(rp);
return fp;
}
int main() {
// The registers.
int registers[2] = {0, 0};
// Our program.
int program[20] = {0, 0, 3,
1, 0, 0, 4,
2, 0};
int* ops = (int*)program;
// Create our function and give us the Module and Function back.
Module* jit;
Function* func = create(&jit);
// Add in optimizations. These were taken from a list that 'opt', LLVMs optimization tool, uses.
PassManager p;
/* Comment out optimize
p.add(new TargetData(jit));
p.add(createVerifierPass());
p.add(createLowerSetJmpPass());
p.add(createRaiseAllocationsPass());
p.add(createCFGSimplificationPass());
p.add(createPromoteMemoryToRegisterPass());
p.add(createGlobalOptimizerPass());
p.add(createGlobalDCEPass());
p.add(createFunctionInliningPass());
*/
// Run these optimizations on our Module
p.run(*jit);
// Setup for JIT
ExistingModuleProvider* mp = new ExistingModuleProvider(jit);
ExecutionEngine* engine = ExecutionEngine::create(mp);
// Show us what we've created!
std::cout << "Created\n" << *jit;
// Have our function JIT'd into machine code and return. We cast it to a particular C function pointer signature so we can call in nicely.
void (*fp)(int*, int*) = (void (*)(int*, int*))engine->getPointerToFunction(func);
// Call what we've created!
fp(ops, registers);
}
int main(int argc, char **argv)
{
InitializeNativeTarget();
LLVMContext &Context = getGlobalContext();
Module *m = new Module("test", Context);
Type *intTy = Type::getInt64Ty(Context);
StructType* structTy = StructType::create(Context, "struct.list");
std::vector<Type*> fields;
fields.push_back(intTy);
fields.push_back(PointerType::get(structTy, 0));
if (structTy->isOpaque()) {
structTy->setBody(fields, false);
}
/*
* int f1(struct x *p) { return p->next->l1; }
*/
std::vector<Type*> args_type;
args_type.push_back(PointerType::get(structTy, 0));
FunctionType *fnTy = FunctionType::get(intTy, args_type, false);
Function *func = Function::Create(fnTy,
GlobalValue::ExternalLinkage, "f1", m);
Value *v = func->arg_begin();
BasicBlock *bb = BasicBlock::Create(Context, "EntryBlock", func);
IRBuilder<> *builder = new IRBuilder<>(bb);
v = builder->CreateStructGEP(v, 1);
v = builder->CreateLoad(v, "load0");
v = builder->CreateStructGEP(v, 0);
v = builder->CreateLoad(v, "load1");
builder->CreateRet(v);
(*m).dump();
{
ExecutionEngine *ee = EngineBuilder(m).
setEngineKind(EngineKind::JIT).create();
void *f = ee->getPointerToFunction(func);
typedef int (*func_t) (struct x *);
struct x o = {10, NULL}, v = {};
v.next = &o;
std::cout << ((func_t)f)(&v) << std::endl;
}
return 0;
}
int main()
{
// Module Construction
LLVMContext &context = llvm::getGlobalContext();
Module *module = new Module("test", context);
//declare 'value' and 'foo' in module 'test'
GlobalVariable *v = cast<GlobalVariable>(module->getOrInsertGlobal("value", Type::getInt32Ty(context)));
// prototype of foo is: int foo(int x)
Function *f = cast<Function>(module->getOrInsertFunction("foo", Type::getInt32Ty(context),
Type::getInt32Ty(context), NULL));
//create a LLVM function 'bar'
Function* bar = cast<Function>(module->getOrInsertFunction("bar", Type::getInt32Ty(context),NULL));
//basic block construction
BasicBlock* entry = BasicBlock::Create(context, "entry", bar);
IRBuilder<> builder(entry);
//read 'value'
Value * v_IR = builder.CreateLoad(v);
//call foo(value)
Value * ret = builder.CreateCall(f, v_IR);
//return return value of 'foo'
builder.CreateRet(ret);
//now bind global value and global function
//create execution engine first
InitializeNativeTarget();
ExecutionEngine *ee = EngineBuilder(module).setEngineKind(EngineKind::JIT).create();
//map global variable
ee->addGlobalMapping(v, &value);
//map global function
ee->addGlobalMapping(f, (void *)foo);
// JIT and run
void *barAddr = ee->getPointerToFunction(bar);
typedef int (*FuncType)();
FuncType barFunc = (FuncType)barAddr;
std::cout << barFunc() << std::endl;
return 0;
}
pair<int, string> execute( string input ){
out = "";
CodeGenerator * codeGen = new CodeGenerator();
node_struct data;
Node * ast = Node::createAST( data );
makeLLVMModule( *ast );
verifyModule( *theModule, PrintMessageAction );
ExecutionEngine *ee = EngineBuilder( theModule ).create();
Function* func = ee -> FindFunctionNamed("main");
typedef int (*PFN)();
PFN pfn = reinterpret_cast<PFN>(ee->getPointerToFunction(func));
int result = pfn();
//printf( "%s\n", out.c_str() );
delete theModule;
return make_pair( result, out );
}
void *MCJITHelper::getPointerToNamedFunction(const std::string &Name)
{
// Look for the functions in our modules, compiling only as necessary
ModuleVector::iterator begin = Modules.begin();
ModuleVector::iterator end = Modules.end();
ModuleVector::iterator it;
for (it = begin; it != end; ++it) {
Function *F = (*it)->getFunction(Name);
if (F && !F->empty()) {
std::map<Module*, ExecutionEngine*>::iterator eeIt = EngineMap.find(*it);
if (eeIt != EngineMap.end()) {
void *P = eeIt->second->getPointerToFunction(F);
if (P)
return P;
} else {
ExecutionEngine *EE = compileModule(*it);
void *P = EE->getPointerToFunction(F);
if (P)
return P;
}
}
}
return NULL;
}
void *MCJITHelper::getPointerToFunction(Function* F) {
// Look for this function in an existing module
ModuleVector::iterator begin = Modules.begin();
ModuleVector::iterator end = Modules.end();
ModuleVector::iterator it;
std::string FnName = F->getName();
for (it = begin; it != end; ++it) {
Function *MF = (*it)->getFunction(FnName);
if (MF == F) {
std::map<Module*, ExecutionEngine*>::iterator eeIt = EngineMap.find(*it);
if (eeIt != EngineMap.end()) {
void *P = eeIt->second->getPointerToFunction(F);
if (P)
return P;
} else {
ExecutionEngine *EE = compileModule(*it);
void *P = EE->getPointerToFunction(F);
if (P)
return P;
}
}
}
return NULL;
}
bool CompiledCondition::compile(){
InitializeNativeTarget();
// Assume we're on main thread...
LLVMContext &context = getGlobalContext();
// Initialize module
Module* module = new Module("Compiled function", context);
// Create exection engine
ExecutionEngine* engine = EngineBuilder(module).create();
/********** Generate code **********/
//Get a type for representing an integer pointer
//Maybe this should be unsigned integer pointer type...
PointerType* integerPointerType = PointerType::get(IntegerType::get(module->getContext(), 32), 0);
//Create function type, for our function, int*, int* -> bool
vector<const Type*> paramType;
paramType.push_back(integerPointerType);
paramType.push_back(integerPointerType);
FunctionType* functionType = FunctionType::get(IntegerType::get(module->getContext(), 8), paramType, false);
//Declare new function
Function* function = Function::Create(functionType, GlobalValue::ExternalLinkage, "evaluate", module);
//Use C calling convention
function->setCallingConv(CallingConv::C); //TODO: Read documentation and reconsider this
//Get arguments from function
Function::arg_iterator args = function->arg_begin();
Value* marking = args++;
Value* valuation = args++;
marking->setName("marking");
valuation->setName("valuation");
//Create function block
BasicBlock* functionBlock = BasicBlock::Create(module->getContext(), "functionBlock", function, 0);
//Generate code
CodeGenerationContext codeGenContext(marking, valuation, functionBlock, context);
Value* result = _cond->codegen(codeGenContext);
//Zero extend the result, e.g. make it a 8 bit bool
CastInst* retval = new ZExtInst(result, IntegerType::get(module->getContext(), 8), "retval", functionBlock);
//Create a return instruction
ReturnInst::Create(module->getContext(), retval, functionBlock);
/********** Optimize and Compile **********/
// Create function pass manager, to optimize query
FunctionPassManager optimizer(module);
optimizer.add(new TargetData(*engine->getTargetData()));
optimizer.add(createBasicAliasAnalysisPass());
optimizer.add(createInstructionCombiningPass());
optimizer.add(createReassociatePass());
optimizer.add(createGVNPass());
optimizer.add(createCFGSimplificationPass());
optimizer.doInitialization();
// Verify function, errors written to stderr
if(verifyFunction(*function))
return false;
// Optimize function
optimizer.run(*function);
// Compile the function
_nativeFunction = (bool(*)(const MarkVal*, const VarVal*))engine->getPointerToFunction(function);
return _nativeFunction != NULL;
}
int main(int argc, char **argv)
{
using namespace llvm;
InitializeNativeTarget();
LLVMContext context;
SMDiagnostic error;
Module *generic_module = ParseIR(MemoryBuffer::getMemBuffer(StringRef(mul_add_ir)), error, context);
if(!generic_module)
{
std::cerr << "Error after first ParseIR" << std::endl;
error.print(argv[0], errs());
std::exit(-1);
}
// create a new module to hold the i32 specialization of generic_module
Module module_i32(StringRef("module_i32"), context);
// maps generic forms to their specializations
ValueToValueMapTy vmap;
specialize_declarations(context, generic_module, vmap, &module_i32);
specialize_definitions(context, generic_module, vmap, &module_i32);
Module *user_module = ParseIR(MemoryBuffer::getMemBuffer(StringRef(int_math_ir)), error, context);
if(!user_module)
{
std::cerr << "Error after second ParseIR" << std::endl;
error.print(argv[0], errs());
std::exit(-1);
}
Linker ld(StringRef(argv[0]), StringRef("mul_add_prog"), context);
std::string error_msg;
if(ld.LinkInModule(&module_i32, &error_msg))
{
std::cerr << "Error after linkInModule(m1)" << std::endl;
std::cerr << error_msg << std::endl;
std::exit(-1);
}
if(ld.LinkInModule(user_module, &error_msg))
{
std::cerr << "Error after linkInModule(user_module)" << std::endl;
std::cerr << error_msg << std::endl;
std::exit(-1);
}
Module *composite = ld.releaseModule();
composite->dump();
ExecutionEngine *ee = ExecutionEngine::create(composite);
Function *func = ee->FindFunctionNamed("mul_add");
if(!func)
{
std::cerr << "Couldn't find mul_add" << std::endl;
std::exit(-1);
}
std::cout << std::endl;
typedef int (*fcn_ptr)(int,int,int);
fcn_ptr mul_add = reinterpret_cast<fcn_ptr>(ee->getPointerToFunction(func));
std::cout << "mul_add(1,2,3): " << mul_add(1,2,3) << std::endl;
delete ee;
return 0;
}
void
gen_and_load_llvm_code (mathmap_t *mathmap, char *template_filename, filter_code_t **filter_codes)
{
MemoryBuffer *buffer = MemoryBuffer::getFile(template_filename, NULL);
g_assert(buffer != NULL);
Module *module = ParseBitcodeFile (buffer, NULL);
int i;
filter_t *filter;
assert(module != NULL);
delete buffer;
for (i = 0, filter = mathmap->filters;
filter != 0;
++i, filter = filter->next)
{
if (filter->kind != FILTER_MATHMAP)
continue;
make_init_frame_function(module, filter);
make_init_x_or_y_function(module, filter, init_x_function_name(filter));
make_init_x_or_y_function(module, filter, init_y_function_name(filter));
make_main_filter_function(module, filter);
make_filter_function(module, filter);
}
for (i = 0, filter = mathmap->filters;
filter != 0;
++i, filter = filter->next)
{
filter_code_t *code = filter_codes[i];
code_emitter *emitter;
if (filter->kind != FILTER_MATHMAP)
continue;
g_assert(code->filter == filter);
emitter = new code_emitter (module, filter, code);
try
{
emitter->emit_init_frame_function();
emitter->emit_filter_function();
emitter->emit_main_filter_funcs();
}
catch (compiler_error error)
{
delete emitter;
delete module;
strcpy(error_string, error.info.c_str());
return;
}
delete emitter;
}
PassManager pm;
pm.add(new TargetData(module));
pm.add(createFunctionInliningPass());
pm.add(createInstructionCombiningPass());
pm.add(createReassociatePass());
pm.add(createLowerSetJmpPass());
pm.add(createRaiseAllocationsPass());
pm.add(createGVNPass());
pm.add(createCFGSimplificationPass());
pm.add(createPromoteMemoryToRegisterPass());
pm.add(createGlobalOptimizerPass());
pm.add(createGlobalDCEPass());
pm.run(*module);
#ifdef DEBUG_OUTPUT
module->dump();
verifyModule(*module, PrintMessageAction);
#endif
ExecutionEngine *ee = ExecutionEngine::create (module);
ee->InstallLazyFunctionCreator(lazy_creator);
module_info_t *module_info = g_new0(module_info_t, 1);
module_info->ee = ee;
void *init_frame_fptr = ee->getPointerToFunction(lookup_init_frame_function(module, mathmap->main_filter));
void *main_filter_fptr = ee->getPointerToFunction(lookup_main_filter_function(module, mathmap->main_filter));
void *init_x_fptr = ee->getPointerToFunction(lookup_init_x_function(module, mathmap->main_filter));
void *init_y_fptr = ee->getPointerToFunction(lookup_init_y_function(module, mathmap->main_filter));
g_assert(main_filter_fptr && init_x_fptr && init_y_fptr);
module_info->mathfuncs.llvm_init_frame_func = (llvm_init_frame_func_t)init_frame_fptr;
module_info->mathfuncs.main_filter_func = (llvm_filter_func_t)main_filter_fptr;
module_info->mathfuncs.init_x_func = (init_x_or_y_func_t)init_x_fptr;
module_info->mathfuncs.init_y_func = (init_x_or_y_func_t)init_y_fptr;
mathmap->module_info = module_info;
mathmap->mathfuncs = &module_info->mathfuncs;
}
int main(int argc, char** argv){
// verif M unit
#ifdef CORE_DBG
verif_m_unit();
#endif
if(argc < 2)
{
return 0;
}
Core *pCore = Core::start();
pCore->init();
COFF_parser parser(argv[1]);
pCore->set_mode(BK_AT_MAIN);
if(argc >= 3)
{
core_mode_t mode = (core_mode_t)strtoul(argv[2],NULL,10);
pCore->set_mode(mode);
}
if(argc >= 4)
{
word_t thres = strtoul(argv[3],NULL,10);
Profiler::set_jit_threshold_times(thres);
}
if(argc >= 5)
{
word_t thres = strtoul(argv[4],NULL,10);
Profiler::set_jit_threshold_len(thres);
}
parser.connect(pCore);
parser.set_reverse(false);
parser.parse();
pCore->init();
#if 0
pCore->reg_write(0,0,2); // A0 = 2
pCore->reg_write(1,0,3); // B0 = 3
llvm::Function *func = llvm::cast<llvm::Function>(Core::get_llvm_module().getOrInsertFunction("func",
Type::getInt32Ty(getGlobalContext()),(Type*)0));
llvm::BasicBlock* bb = llvm::BasicBlock::Create(getGlobalContext(),"entry",func);
Core::get_llvm_builder().SetInsertPoint(bb);
llvm::Constant* a_side_addr = llvm::ConstantInt::get(llvm::Type::getInt32Ty(getGlobalContext())
,(uint64_t)pCore->get_reg_a());
llvm::Constant* b_side_addr = llvm::ConstantInt::get(llvm::Type::getInt32Ty(getGlobalContext())
,(uint64_t)pCore->get_reg_b());
llvm::Constant* dst_addr = llvm::ConstantInt::get(llvm::Type::getInt32Ty(getGlobalContext())
,(uint64_t)(pCore->get_reg_b()+1)); // B1
llvm::Value* a_side = llvm::ConstantExpr::getIntToPtr(a_side_addr,
llvm::PointerType::getUnqual(llvm::Type::getInt32Ty(getGlobalContext())));
llvm::Value* b_side = llvm::ConstantExpr::getIntToPtr(b_side_addr,
llvm::PointerType::getUnqual(llvm::Type::getInt32Ty(getGlobalContext())));
llvm::Value* b1 = llvm::ConstantExpr::getIntToPtr(dst_addr,
llvm::PointerType::getUnqual(llvm::Type::getInt32Ty(getGlobalContext())));
llvm::Value* left = Core::get_llvm_builder().CreateLoad(a_side);
llvm::Value* right = Core::get_llvm_builder().CreateLoad(b_side);
llvm::Value* re = Core::get_llvm_builder().CreateAdd(left,right);
Core::get_llvm_builder().CreateStore(re,b1,true);
Core::get_llvm_builder().CreateRet(re);
ExecutionEngine* EE = EngineBuilder(&Core::get_llvm_module()).create();
// Call the `foo' function with no arguments:
//std::vector<GenericValue> noargs;
//GenericValue gv = EE->runFunction(func, noargs);
void* FPtr = EE->getPointerToFunction(func);
int (*FP)() = (int (*)())(intptr_t)FPtr;
FP();
// Import result of execution:
std::cout << "Result: " << pCore->reg_read(B_SIDE,1) << "\n";
//outs() << "re: " << gv.IntVal << "\n";
#endif
#if 0
pCore->reg_write(A_SIDE,3,0xFF);
de_func_t de_func = JIT::gen_su_de_32bit_1or2_src_shl_f2_nc(pCore,0x018d0ca0);
c6x::Instruction inst;
pCore->reg_ch_num = 1;
de_func(pCore,&inst);
pCore->step();
std::cout << to_hex_str(pCore->reg_read(A_SIDE,3)) << "\n";
system("pause");
#endif
pCore->run();
return 0;
}
int main(int argc, char* argv[])
{
if(argc < 2)
{
cerr << "Usage: " << argv[0] << " bf_file" << endl;
return -1;
}
ifstream sourceFile(argv[1]);
string line, source;
while(getline(sourceFile, line)) source += line;
// Setup a module and engine for JIT-ing
std::string error;
InitializeNativeTarget();
Module* module = new Module("bfcode", getGlobalContext());
InitializeNativeTarget();
LLVMLinkInJIT();
ExecutionEngine *engine = EngineBuilder(module)
.setErrorStr(&error)
.setOptLevel(CodeGenOpt::Aggressive)
.create();
if(!engine)
{
cout << "No engine created: " << error << endl;
return -1;
}
module->setDataLayout(engine->getTargetData()->getStringRepresentation());
// Compile the BF to IR
cout << "Parsing… " << flush;
Function* func = makeFunc(module, source.c_str());
cout << "done" << endl;
{
ofstream dst("out.ll");
raw_os_ostream rawdst(dst);
rawdst << *module;
}
// Run optimization passes
cout << "Optimizing… " << flush;
PassManagerBuilder PMBuilder;
FunctionPassManager pm(module);
PMBuilder.populateFunctionPassManager(pm);
pm.add(new TargetData(*(engine->getTargetData())));
pm.add(createVerifierPass());
// Eliminate simple loops such as [>>++<<-]
pm.add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
pm.add(createLICMPass()); // Hoist loop invariants
pm.add(createPromoteMemoryToRegisterPass());
pm.add(createIndVarSimplifyPass()); // Canonicalize indvars
pm.add(createLoopDeletionPass()); // Delete dead loops
pm.add(createConstantPropagationPass()); // Propagate constants
pm.add(new CondProp); // Propagate conditionals
// Simplify code
for(int repeat=0; repeat < 3; repeat++)
{
pm.add(createPromoteMemoryToRegisterPass());
pm.add(createGVNPass()); // Remove redundancies
pm.add(createSCCPPass()); // Constant prop with SCCP
pm.add(createLoopDeletionPass());
pm.add(createLoopUnrollPass());
pm.add(createCFGSimplificationPass()); // Merge & remove BBs
pm.add(createInstructionCombiningPass());
pm.add(createConstantPropagationPass()); // Propagate constants
pm.add(createAggressiveDCEPass()); // Delete dead instructions
pm.add(createCFGSimplificationPass()); // Merge & remove BBs
pm.add(createDeadStoreEliminationPass()); // Delete dead stores
pm.add(createMemCpyOptPass()); // Combine multiple stores into memset's
//pm.add(new PutCharAggregatePass);
}
pm.add(createPromoteMemoryToRegisterPass());
// Process
foreach (Function& f, *module)
if (!f.isDeclaration)
pm.run(f);
PassManager pmm;
PMBuilder.populateModulePassManager(pmm);
pmm.add(createConstantMergePass());
pmm.add(createGlobalOptimizerPass());
pmm.add(createGlobalDCEPass());
pmm.add(createIPConstantPropagationPass());
pmm.run(*module);
foreach (Function& f, *module)
if (!f.isDeclaration)
pm.run(f);
pmm.run(*module);
cout << "done" << endl;
{
ofstream dst("optout.ll");
raw_os_ostream rawdst(dst);
rawdst << *module;
}
// Compile …
cout << "Compiling…" << flush;
int (*bf)() = (int (*)())engine->getPointerToFunction(func);
cout << " done" << endl;
// … and run!
return bf();
}
void *MCJITHelper::getPointerToFunction(Function* F) {
// See if an existing instance of MCJIT has this function.
EngineVector::iterator begin = Engines.begin();
EngineVector::iterator end = Engines.end();
EngineVector::iterator it;
for (it = begin; it != end; ++it) {
void *P = (*it)->getPointerToFunction(F);
if (P)
return P;
}
// If we didn't find the function, see if we can generate it.
if (OpenModule) {
std::string ErrStr;
ExecutionEngine *NewEngine = EngineBuilder(OpenModule)
.setErrorStr(&ErrStr)
.setMCJITMemoryManager(new HelpingMemoryManager(this))
.create();
if (!NewEngine) {
fprintf(stderr, "Could not create ExecutionEngine: %s\n", ErrStr.c_str());
exit(1);
}
// Create a function pass manager for this engine
FunctionPassManager *FPM = new FunctionPassManager(OpenModule);
// Set up the optimizer pipeline. Start with registering info about how the
// target lays out data structures.
FPM->add(new DataLayout(*NewEngine->getDataLayout()));
// Provide basic AliasAnalysis support for GVN.
FPM->add(createBasicAliasAnalysisPass());
// Promote allocas to registers.
FPM->add(createPromoteMemoryToRegisterPass());
// Do simple "peephole" optimizations and bit-twiddling optzns.
FPM->add(createInstructionCombiningPass());
// Reassociate expressions.
FPM->add(createReassociatePass());
// Eliminate Common SubExpressions.
FPM->add(createGVNPass());
// Simplify the control flow graph (deleting unreachable blocks, etc).
FPM->add(createCFGSimplificationPass());
FPM->doInitialization();
// For each function in the module
Module::iterator it;
Module::iterator end = OpenModule->end();
for (it = OpenModule->begin(); it != end; ++it) {
// Run the FPM on this function
FPM->run(*it);
}
// We don't need this anymore
delete FPM;
OpenModule = NULL;
Engines.push_back(NewEngine);
NewEngine->finalizeObject();
return NewEngine->getPointerToFunction(F);
}
return NULL;
}
