def run_tests():
for name in test_inputs:
parser = SLRParser("new_grammar.txt", '../testInputs/' + name + '.txt')
syn_tree = parser.parse()[0]
syn_tree.genCases(parser.grammar)
sym_table = SymbolTable()
named_sym_table = NamedSymbolTable()
valid = errorCheck(syn_tree, sym_table, named_sym_table,
parser.lexer.infileLines)
llvm_custom_types = create_llvm_types(named_sym_table)
module = ir.Module(name=name)
generated_ir = codegen(syn_tree, named_sym_table, {
'mod': module,
'llvm_custom_types': llvm_custom_types
})
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter() # yes, even this one
binding.load_library_permanently('../runtime.so')
binding.parse_assembly(str(module), None)
engine = create_execution_engine()
mod = compile_ir(engine, str(module))
test_inputs[name](engine)
def JIT(file_name, function_name, args, opt_on=False, verbose=False):
src = ""
with open(file_name, "r") as src_file:
src = src_file.read()
if (verbose):
print("Reading source:")
print(src)
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
transformer = pAST.PythonVisitor()
ast = transformer(src)
module = ir.Module(name="JITPy")
#for only 1 arg
args_in = []
if (len(args_in) == 1):
args.append(args)
else:
args_in = args
infer_ty, ret_ty, arg_tys = type_infer(src, ast, function_name, args_in)
#print(infer_ty)
ir_module = specialize(ast, infer_ty)
llvm_ir = str(ir_module)
if (verbose):
print(llvm_ir)
engine = create_execution_engine()
mod = compile_ir(engine, llvm_ir)
cfunc = wrap_function(ret_ty, args_in, function_name, engine)
result = cfunc(*args_in)
result_str = function_name + "(" + str(args_in) + ")" + " = " + str(result)
print(result_str)
def setUp(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
gc.collect()
self.old_garbage = gc.garbage[:]
gc.garbage[:] = []
def run(llvm_ir):
# Load the runtime
ctypes._dlopen(os.path.join(_path, 'gonert.so'), ctypes.RTLD_GLOBAL)
# Initialize LLVM
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
target = llvm.Target.from_default_triple()
target_machine = target.create_target_machine()
mod = llvm.parse_assembly(llvm_ir)
mod.verify()
engine = llvm.create_mcjit_compiler(mod, target_machine)
# Execute the main() function
#
# !!! Note: Requires modification in Project 8 (see below)
# main_ptr = engine.get_function_address('main')
# main_func = ctypes.CFUNCTYPE(None)(main_ptr)
# main_func()
init_ptr = engine.get_function_address('__init')
init_func = ctypes.CFUNCTYPE(None)(init_ptr)
init_func()
main_ptr = engine.get_function_address('_gone_main')
main_func = ctypes.CFUNCTYPE(None)(main_ptr)
main_func()
def main():
"""Entry point for the CLI."""
# Tokenize the input:
file_stream = FileStream(sys.argv[1]) # FIXME: use argparse/click.
lexer = XLexer(file_stream)
token_stream = CommonTokenStream(lexer)
# Parse the program:
parser = XParser(token_stream)
tree = parser.program()
# Compile the code:
code_generator = CodeGenerator()
code_generator.visit(tree)
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
target = llvm.Target.from_default_triple()
target_machine = target.create_target_machine()
backing_module = llvm.parse_assembly('')
engine = llvm.create_mcjit_compiler(backing_module, target_machine)
module = llvm.parse_assembly(code_generator.code)
module.verify()
engine.add_module(module)
engine.finalize_object()
func_ptr = engine.get_function_address('main')
c_func = CFUNCTYPE(c_int)(func_ptr)
print(c_func())
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.codegen = LLVMCodeGenerator()
self.target = llvm.Target.from_default_triple()
def test_inline_asm(self):
"""The InlineAsm class from llvmlite.ir has no 'name' attr the refcount
pruning pass should be tolerant to this"""
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
llvm.initialize_native_asmparser()
@intrinsic
def bar(tyctx, x, y):
def codegen(cgctx, builder, sig, args):
(arg_0, arg_1) = args
fty = ir.FunctionType(
ir.IntType(64),
[ir.IntType(64), ir.IntType(64)])
mul = builder.asm(fty,
"mov $2, $0; imul $1, $0",
"=r,r,r", (arg_0, arg_1),
name="asm_mul",
side_effect=False)
return impl_ret_untracked(cgctx, builder, sig.return_type, mul)
return signature(x, x, x), codegen
@njit(['int64(int64)'])
def foo(x):
x += 1
z = bar(x, 2)
return z
self.assertEqual(foo(10), 22) # expect (10 + 1) * 2 = 22
def execute(ir_mod):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
llmod = llvm.parse_assembly(str(ir_mod))
print('optimized'.center(80, '-'))
pmb = llvm.create_pass_manager_builder()
pmb.opt_level = 1
pm = llvm.create_module_pass_manager()
pmb.populate(pm)
pm.run(llmod)
print(llmod)
target_machine = llvm.Target.from_default_triple().create_target_machine()
with llvm.create_mcjit_compiler(llmod, target_machine) as ee:
ee.finalize_object()
cfptr = ee.get_function_address("entry_fib")
from ctypes import CFUNCTYPE, c_int
cfunc = CFUNCTYPE(c_int, c_int)(cfptr)
# TEST
for i in range(12):
res = cfunc(i)
print('fib({}) = {}'.format(i, res))
# Get CFG
ll_fib_more = llmod.get_function('fib_more')
cfg = llvm.get_function_cfg(ll_fib_more)
llvm.view_dot_graph(cfg, view=True)
def initialize_codegen():
# init LLVM
logger.debug('Initialize LLVM bindings')
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmparser()
binding.initialize_native_asmprinter()
def compile_ir(self):
"""
Execute generated code.
"""
# initialize the LLVM machine
# These are all required (apparently)
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
# Create engine and attach the generated module
# Create a target machine representing the host
target = llvm.Target.from_default_triple()
target_machine = target.create_target_machine()
# And an execution engine with an empty backing module
backing_mod = llvm.parse_assembly("")
engine = llvm.create_mcjit_compiler(backing_mod, target_machine)
# Parse our generated module
mod = llvm.parse_assembly(str(self.module))
mod.verify()
# Now add the module and make sure it is ready for execution
engine.add_module(mod)
engine.finalize_object()
# Look up the function pointer (a Python int)
func_ptr = engine.get_function_address("main")
# Run the function via ctypes
c_fn = CFUNCTYPE(c_int)(func_ptr)
c_fn()
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.target = llvm.Target.from_default_triple()
self.reset()
def initialize_llvm():
global _llvm_initialized
if not _llvm_initialized:
ll.initialize()
ll.initialize_native_target()
ll.initialize_native_asmprinter()
_llvm_initialized = True
def run(llvm_ir):
# Load the runtime
if os.name != 'nt':
ctypes._dlopen(os.path.join(_path, 'gonert.so'), ctypes.RTLD_GLOBAL)
else:
ctypes._dlopen(os.path.join(_path, 'gonert.dll'), ctypes.RTLD_GLOBAL)
# Initialize LLVM
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
target = llvm.Target.from_default_triple()
target_machine = target.create_target_machine()
mod = llvm.parse_assembly(llvm_ir)
mod.verify()
engine = llvm.create_mcjit_compiler(mod, target_machine)
# Execute the main() function
#
# !!! Note: Requires modification in Project 8 (see below)
init_ptr = engine.get_function_address('__init')
init_func = ctypes.CFUNCTYPE(None)(init_ptr)
init_func()
main_ptr = engine.get_function_address('_gone_main')
main_func = ctypes.CFUNCTYPE(None)(main_ptr)
main_func()
def test_inline_asm(self):
"""The InlineAsm class from llvmlite.ir has no 'name' attr the refcount
pruning pass should be tolerant to this"""
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
llvm.initialize_native_asmparser()
@intrinsic
def bar(tyctx, x, y):
def codegen(cgctx, builder, sig, args):
(arg_0, arg_1) = args
fty = ir.FunctionType(ir.IntType(64), [ir.IntType(64),
ir.IntType(64)])
mul = builder.asm(fty, "mov $2, $0; imul $1, $0", "=r,r,r",
(arg_0, arg_1), name="asm_mul",
side_effect=False)
return impl_ret_untracked(cgctx, builder, sig.return_type, mul)
return signature(x, x, x), codegen
@njit(['int64(int64)'])
def foo(x):
x += 1
z = bar(x, 2)
return z
self.assertEqual(foo(10), 22) # expect (10 + 1) * 2 = 22
def main():
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
i64 = ir.IntType(64)
# int64_t main()
ftype_main = ir.FunctionType(i64, [])
module = ir.Module(name='sokoide_module')
fn_main = ir.Function(module, ftype_main, name="main")
block = fn_main.append_basic_block(name='entrypoint')
# function prototype (external linkage implemented in builtin.c) for
# void write(int64_t)
ftype_write = ir.FunctionType(ir.VoidType(), [i64])
fn_write = ir.Function(module, ftype_write, name="write")
# make a block for main (entrypoint)
builder = ir.IRBuilder(block)
# call write(42)
builder.call(fn_write, (ir.Constant(i64, 42), ), name="write")
# return 42
builder.ret(ir.Constant(i64, 42))
llvm_ir = str(module)
llvm_ir_parsed = llvm.parse_assembly(llvm_ir)
with open("out.ll", "w") as f:
f.write(str(llvm_ir_parsed))
def __init__(self, code):
self.semantica = Semantica(code)
self.arvore = self.semantica.ast
llvm.initialize()
llvm.initialize_all_targets()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.module = ir.Module('meu_modulo.bc')
self.module.triple = llvm.get_process_triple()
target = llvm.Target.from_triple(self.module.triple)
target_machine = target.create_target_machine()
self.module.data_layout = target_machine.target_data
#llvm.shutdown()
self.variaveis = []
self.variaveisGlobais = []
self.escopo = "global"
self.funcs = []
self.andaArvore(self.arvore)
self.funcllvm = ''
self.endBlock = ''
arquivo = open('meu_modulo.ll', 'w')
arquivo.write(str(self.module))
arquivo.close()
print(self.module)
def init_llvm(basename):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
global gLlvmModule
gLlvmModule = ir.Module(name=basename)
def __init__(self, **kwargs):
self.info = {"global_variables": []}
self.local_vars = []
self.aux = []
self.functions = []
self.module = ir.module.Module()
llvm.initialize()
llvm.initialize_all_targets()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.module = ir.Module('module.bc')
self.module.triple = llvm.get_default_triple()
target = llvm.Target.from_triple(self.module.triple)
target_machine = target.create_target_machine()
self.module.data_layout = target_machine.target_data
self.escrevaInteiro = ir.Function(self.module,
ir.FunctionType(
ir.VoidType(), [ir.IntType(32)]),
name="escrevaInteiro")
self.escrevaFlutuante = ir.Function(self.module,
ir.FunctionType(
ir.VoidType(),
[ir.FloatType()]),
name="escrevaFlutuante")
self.leiaInteiro = ir.Function(self.module,
ir.FunctionType(ir.IntType(32), []),
name="leiaInteiro")
self.leiaFlutuante = ir.Function(self.module,
ir.FunctionType(ir.FloatType(), []),
name="leiaFlutuante")
def initialize_llvm():
global _llvm_initialized
if not _llvm_initialized:
ll.initialize()
ll.initialize_native_target()
ll.initialize_native_asmprinter()
_llvm_initialized = True
def target_initialize(self):
"""
Initialize LLVM for target.
"""
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
def Codegen(ast: ProgramNode, printIR: bool = True):
"""Genera l'LLVM IR dall'AST in input.
Args:
ast: L'albero di sintassi astratto.
printIR (bool): Un boolean che indica se fare un print dell'IR generato (default `False`)
Returns:
L'IR generato sotto forma di `str`
Raises:
StdlibNotFoundError: Se la standard lib non puo' essere trovata
"""
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
# Decide l'estensione della stdlib
ext = None
if platform.system() == 'Windows':
ext = 'dll'
elif platform.system() == 'Darwin':
ext = 'dylib'
elif platform.system() == 'Linux':
ext = 'so'
path = pathlib.Path(__file__).parent.absolute()
try:
llvm.load_library_permanently(
str(path) + "/../../bin/tiny_hi_core.{}".format(ext))
except Exception:
print("StdlibNotFoundError: Cannot find the standard library (tiny_hi_core.{})".format(ext))
return (None, None)
module = Module()
builder = IRBuilder()
context = Context(module)
entry = None
llmod = None
try:
entry = ast.entry_point()
ast.codegen(builder, context)
strmod = str(module)
if printIR:
print(strmod)
llmod = llvm.parse_assembly(strmod)
except Exception as e:
print("Codegen Failed")
print("{}: {}".format(type(e).__name__, e))
finally:
return (llmod, entry)
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.codegen = LLVMCodeGenerator()
self.target = llvm.Target.from_default_triple()
def main(optimize: bool):
text = FileStream("test.txt")
lexer = WappaLexer(text)
tokens = CommonTokenStream(lexer)
parser = Wappa(tokens)
parser.buildParseTrees = True
tree = parser.compilationUnit()
visitor = WappaVisitor()
module = visitor.visit(tree)
with open("ex/test.ll", "w") as f:
f.write(module)
# print('=== LLVM IR')
# print(module)
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
llvm_module = llvm.parse_assembly(str(module))
if optimize:
builder = llvm.create_pass_manager_builder()
builder.inlining_threshold = 2
builder.loop_vectorize = True
builder.opt_level = 3
builder.slp_vectorize = True
mpm = llvm.create_module_pass_manager()
builder.populate(mpm)
mpm.run(llvm_module)
tm = llvm.Target.from_default_triple().create_target_machine()
with llvm.create_mcjit_compiler(llvm_module, tm) as ee:
ee.finalize_object()
asm = tm.emit_assembly(llvm_module)
# print('=== Assembly')
# print(asm)
with open('ex/test.asm', 'w') as f:
f.write(asm)
print('The result of "sum" is',
get_func(ee, 'sum', c_int, c_int, c_int)(17, 42))
print('The result of "eq" is',
get_func(ee, 'eq', c_bool, c_double, c_double)(17, 42))
print('The result of "eq" is',
get_func(ee, 'eq', c_bool, c_double, c_double)(42, 42))
print('The result of "neq" is',
get_func(ee, 'neq', c_bool, c_double, c_double)(17, 42))
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.builder = ll.IRBuilder()
self.variable_table = {}
fntype = ll.FunctionType(ll.VoidType(), [])
self.module = ll.Module()
self.func = ll.Function(self.module, fntype, name='main')
def main():
m = ir.Module()
func_ty = ir.FunctionType(ir.VoidType(), [])
i32_ty = ir.IntType(32)
func = ir.Function(m, func_ty, name="printer")
voidptr_ty = ir.IntType(8).as_pointer()
fmt = "Hello, %s! %i times!\n\0"
c_fmt = ir.Constant(ir.ArrayType(ir.IntType(8), len(fmt)),
bytearray(fmt.encode("utf8")))
global_fmt = ir.GlobalVariable(m, c_fmt.type, name="fstr")
global_fmt.linkage = 'internal'
global_fmt.global_constant = True
global_fmt.initializer = c_fmt
arg = "World\0"
c_str_val = ir.Constant(ir.ArrayType(ir.IntType(8), len(arg)),
bytearray(arg.encode("utf8")))
printf_ty = ir.FunctionType(ir.IntType(32), [voidptr_ty], var_arg=True)
printf = ir.Function(m, printf_ty, name="printf")
builder = ir.IRBuilder(func.append_basic_block('entry'))
c_str = builder.alloca(c_str_val.type)
builder.store(c_str_val, c_str)
# this val can come from anywhere
int_val = builder.add(i32_ty(5), i32_ty(3))
fmt_arg = builder.bitcast(global_fmt, voidptr_ty)
builder.call(printf, [fmt_arg, c_str, int_val])
builder.ret_void()
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
f = open("test.txt", "w")
old = sys.stdout
sys.stdout = f
print(str(m))
sys.stdout = old
f.close()
f = open("test.txt", "r")
print(f.read())
f.close()
llvm_module = llvm.parse_assembly(str(m))
tm = llvm.Target.from_default_triple().create_target_machine()
with llvm.create_mcjit_compiler(llvm_module, tm) as ee:
ee.finalize_object()
fptr = ee.get_function_address("printer")
py_func = CFUNCTYPE(None)(fptr)
py_func()
def get_jit_engine():
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter()
target = binding.Target.from_default_triple()
target_machine = target.create_target_machine()
backing_module = binding.parse_assembly("")
return binding.create_mcjit_compiler(backing_module, target_machine)
def _ensure_llvm():
"""Ensure that LLVM has been initialised."""
if _ensure_llvm.was_initialized:
return
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
_ensure_llvm.was_initialized = True
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.target = llvm.Target.from_default_triple()
backing_mod = llvm.parse_assembly("")
self.engine = llvm.create_mcjit_compiler(backing_mod,
self.target.create_target_machine())
def bindAndRun(self):
print("Binding to LLVM and running. Here is the LLVM to be run:")
llvm.load_library_permanently(r"./runtime/runtimelib.so")
void = self.getType("void")
# self.builder.ret_void()
self.builder.ret(self.getType("true"))
#print(self.builder.basic_block)
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter() # yes, even this one
llvm_ir = self.getIR()
print("------------------Output-----------------------")
def create_execution_engine():
"""
Create an ExecutionEngine suitable for JIT code generation on
the host CPU. The engine is reusable for an arbitrary number of
modules.
"""
# Create a target machine representing the host
target = llvm.Target.from_default_triple()
target_machine = target.create_target_machine()
# And an execution engine with an empty backing module
backing_mod = llvm.parse_assembly("")
engine = llvm.create_mcjit_compiler(backing_mod, target_machine)
return engine
def compile_ir(engine, llvm_ir):
"""
Compile the LLVM IR string with the given engine.
The compiled module object is returned.
"""
# Create a LLVM module object from the IR
mod = llvm.parse_assembly(llvm_ir)
mod.verify()
# Now add the module and make sure it is ready for execution
engine.add_module(mod)
engine.finalize_object()
engine.run_static_constructors()
return mod
engine = create_execution_engine()
mod = compile_ir(engine, llvm_ir)
# Look up the function pointer (a Python int)
func_ptr = engine.get_function_address("main")
# Run the function via ctypes
cfunc = CFUNCTYPE(c_bool)(func_ptr)
res = cfunc()
print("Exit: ", res)
def __init__(self, input_fName, output_fName):
self.symbolTable = SymbolTable()
self.parser = Parser(input_fName)
self.output_fName = output_fName
self._has_errors = False
# llvm setup
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter()
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.env = dict()
self.module = ir.Module(name=__file__)
self._headers()
self._main()
self.target = llvm.Target.from_default_triple()
def __init__(self):
bind.initialize()
bind.initialize_native_target()
bind.initialize_native_asmprinter() # yes, even this one
# Create a target machine representing the host
target = bind.Target.from_default_triple()
self.target_machine = target.create_target_machine()
# And an execution engine with an empty backing module
backing_mod = bind.parse_assembly("")
self.engine = bind.create_mcjit_compiler(backing_mod, self.target_machine)
def gen_asm(llvm_ir):
# All these initializations are required for code generation!
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter() # yes, even this one
engine = create_execution_engine()
mod = compile_ir(engine, str(ir_ula.module))
return target_machine.emit_assembly(mod)
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.codegen = LLVMCodeGenerator()
self.parser = Parser()
self._add_builtins(self.codegen.module)
self.target = llvm.Target.from_default_triple()
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.codegen = LLVMCodeGenerator()
self.parser = Parser()
self._add_builtins(self.codegen.module)
self.target = llvm.Target.from_default_triple()
def __init__(self, name: str):
self.module = ir.Module(name=name)
self.functypes: Dict[str, Tuple[Ftypein, Ftypeout]] = dict()
self.funcs: Dict[str, ir.Function] = dict()
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter()
target: binding.Target = binding.Target.from_default_triple()
self.target_machine: binding.TargetMachine = target.create_target_machine(
)
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.prop={}
self.function_name_table = {}
self.function_symbol_table = {}
self.var_symbolTBL = {}
self.var_ptr_symbolTBL = {}
self.var_ptr_symbolTBL['var_symbolTBL'] = self.var_symbolTBL
self.tm = llvm.Target.from_default_triple().create_target_machine()
def __init__(self, triple="DEFAULT"):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
if triple == "DEFAULT":
target = llvm.Target.from_default_triple()
else:
target = llvm.Target.from_triple(triple=triple)
self.target_machine = target.create_target_machine()
backing_mod = llvm.parse_assembly("")
self.engine = llvm.create_mcjit_compiler(module=backing_mod, target_machine=self.target_machine)
def run_ir(llvm_ir):
# All these initializations are required for code generation!
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter() # yes, even this one
engine = create_execution_engine()
mod = compile_ir(engine, llvm_ir)
# Run the code
func_ptr = engine.get_function_address("main")
cfunc = CFUNCTYPE(c_float)(func_ptr)
res = cfunc()
return res
def __init__(self, module):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.module = module
self.module.translate()
self.cge = CGEnv()
self.cge.module = module
self.llvm = self.makeStub()
for _, func in self.module.namestore.all(ir.Function):
self.blockAndCode(func)
self.target_machine = llvm.Target.from_default_triple().create_target_machine()
logging.debug("Verifying... ")
self._llmod = None
from __future__ import print_function
from ctypes import CFUNCTYPE, c_double
import llvmlite.binding as llvm
# All these initializations are required for code generation!
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter() # yes, even this one
llvm_ir = """
; ModuleID = "examples/ir_fpadd.py"
target triple = "unknown-unknown-unknown"
target datalayout = ""
define double @"fpadd"(double %".1", double %".2")
{
entry:
%"res" = fadd double %".1", %".2"
ret double %"res"
}
"""
def create_execution_engine():
"""
Create an ExecutionEngine suitable for JIT code generation on
the host CPU. The engine is reusable for an arbitrary number of
modules.
"""
import subprocess
import sys
import os
import stat
from llvmlite import ir, binding
SOURCE_DIRECTORY = pathlib.Path(__file__).parent.resolve() / 'bbprogram'
SOURCE_FILENAME = 'bbprogram.s'
EXECUTABLE_FILENAME = 'bbprogram'
SYSTEM_SHARED = pathlib.Path('/usr/lib/x86_64-linux-gnu')
# All these initializations are required for code generation!
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter() # yes, even this one
# Load libraries
def load_shared_library(name):
"""Find and load shared library."""
if (SOURCE_DIRECTORY / name).exists():
binding.load_library_permanently(str(SOURCE_DIRECTORY / name))
else:
binding.load_library_permanently(str(SYSTEM_SHARED / name))
# Create some useful types
UCHAR_T = ir.IntType(16)
USTR_T = ir.PointerType(UCHAR_T)
INT32_T = ir.IntType(32)
FLOAT32_T = ir.FloatType()
VOID_T = ir.VoidType()
def init():
llvm.initialize()
llvm.initialize_all_targets()
llvm.initialize_native_asmprinter()
llvm.initialize_native_target()
def initialize_llvm():
"""Safe to use multiple times.
"""
ll.initialize()
ll.initialize_native_target()
ll.initialize_native_asmprinter()
def setUp(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
if __name__ == "__main__":
if len(sys.argv) != 2:
print("Usage: %s (llvmlite|llvmpy)"
% (sys.executable,), file=sys.stderr)
sys.exit(1)
impl = sys.argv[1]
if impl == 'llvmlite':
import llvmlite.binding as llvm
import llvmlite.llvmpy.core as lc
from llvmlite.llvmpy import ee
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
del llvm
elif impl == 'llvmpy':
import llvm.core as lc
from llvm import ee
else:
raise RuntimeError("Wrong implementation %r" % (impl,))
for i in range(3):
run_bench(True)
print()
from ctypes import CFUNCTYPE, c_int32
import llvmlite.ir as ir
import llvmlite.binding as binding
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter()
def make_add_fn():
global ee
int32 = llvm.ir.IntType(32)
module = ir.Module()
adder_type = ir.FunctionType(int32, (int32, int32))
adder = ir.Function(module, adder_type, 'add')
adder.args[0].name = 'a'
adder.args[1].name = 'b'
bb_entry = adder.append_basic_block('entry')
irbuilder = ir.IRBuilder(bb_entry)
s = irbuilder.add(adder.args[0], adder.args[1])
irbuilder.ret(s)
llvm_module = binding.parse_assembly(str(module))
tm = binding.Target.from_default_triple().create_target_machine()
ee = binding.create_mcjit_compiler(llvm_module, tm)
ee.finalize_object()
cfptr = ee.get_function_address('add')