def create_module(self, name):
mod = lc.Module.new(name)
mod.triple = ll.get_default_triple()
if self._data_layout:
mod.data_layout = self._data_layout
return mod
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 generate(self, ast=[[]], output="output.ll"):
self.variables = {}
self.constants = {}
self.functions = {}
self.scope = ''
self.module = ir.Module(name=output)
triple = binding.get_default_triple()
self.module.triple = "" # the default triple from llvmlite seems to not work on some devices.
self.setup_std_funcs()
main_ty = ir.FunctionType(ir.IntType(32), ())
self.main = ir.Function(self.module, main_ty, name="main")
self.scope = self.main
main_block = self.scope.append_basic_block(name="entry")
builder = ir.IRBuilder(main_block)
for statement in ast[0]:
builder = self.codegen(statement, builder)
builder.ret(ir.IntType(32)(0))
return self.module
def test_create_target_machine(self):
target = llvm.Target.from_triple(llvm.get_default_triple())
# With the default settings
target.create_target_machine('', '', 1, 'default', 'default')
# With the host's CPU
cpu = llvm.get_host_cpu_name()
target.create_target_machine(cpu, '', 1, 'default', 'default')
def __init__(self, file=None, name=None):
S.Scope.__init__(self)
if name:
self.qname = self.mname = name
else:
self.file = file
self.qname, self.mname = find_name(self.file)
self.llvm = ir.Module(name=self.qname)
self.llvm.triple = binding.get_default_triple()
self.imports = set()
self.links = set()
self.libs = set()
self.runtime = runtime.Runtime(self)
self.static = static.Static(self)
self.runtime.declare()
typ = T.arr(T.i8, len(self.qname) + 1)
ptr = self.add_global(typ, name=self.mangle('_name'))
ptr.initializer = typ(bytearray(self.qname + '\0', 'utf-8'))
self.name_ptr = ptr.gep([T.i32(0), T.i32(0)])
self.builder = None
self.arg_ptrs = None
self.landingpad = None
self.before = None
self.loop = None
self.after = None
self.ret_ptr = None
self.name_counter = 0
def template_string(self, index):
"""
Generate template string to be used in LLVM IR call asm.
This is used to disambiguate different usage types of a single register
from its constaint code.
E.g. on aarch64 targets float types will append a shape parameter to
differentiate between single and double precision types.
:param index: Index to use for input or output constraints.
"""
# Optional ${reg:shape} parameter
shape = None
# Optional ${reg}.suffix parameter
suffix = None
target_triple = llvm.get_default_triple()
if target_triple.startswith('aarch64-'):
shape = aarch64_llvm_type_shape.get(self.llvm_type)
suffix = aarch64_llvm_type_suffix.get(self.llvm_type)
if shape == None:
shape = ''
else:
shape = ':' + shape
if suffix == None:
suffix = ''
else:
suffix = '.' + suffix
return '${{{}{}}}{}'.format(index, shape, suffix)
def __init__(self) -> None:
self.module: ll.Module = ll.Module("zet")
self.module.triple = llvm.get_default_triple()
self.block : ll.Block = None
self.builder: ll.IRBuilder = None
self.variables = {}
self.functions = {}
self.methods = {}
self.structs = {}
self.flags = { "string" : 0 }
self.modifiers = {
"attribute" : Attribute(),
"static": Static(),
}
self.sizes = {
"i32" : 4,
"i8" : 1,
"str" : 1,
"void": 0,
}
self.types = {
"i32" : ll.IntType(32),
"i8" : ll.IntType(8),
"str" : ll.IntType(8).as_pointer(),
"void": ll.VoidType()
}
def test_from_triple(self):
f = llvm.Target.from_triple
with self.assertRaises(RuntimeError) as cm:
f("foobar")
self.assertIn("No available targets are compatible with this triple", str(cm.exception))
triple = llvm.get_default_triple()
target = f(triple)
self.assertEqual(target.triple, triple)
target.close()
def host(cls, name='host_cpu', strict=False, use_tracing_allocator=False):
"""Return target info for host CPU.
"""
key = (name, strict, use_tracing_allocator)
target_info = TargetInfo._host_target_info_cache.get(key)
if target_info is not None:
return target_info
import llvmlite.binding as ll
target_info = cls(name=name,
strict=strict,
use_tracing_allocator=use_tracing_allocator)
target_info.set('name', ll.get_host_cpu_name())
target_info.set('triple', ll.get_default_triple())
features = ','.join(
['-+'[int(v)] + k for k, v in ll.get_host_cpu_features().items()])
target_info.set('features', features)
for tname, ctype in dict(bool=ctypes.c_bool,
size_t=ctypes.c_size_t,
ssize_t=ctypes.c_ssize_t,
char=ctypes.c_char,
uchar=ctypes.c_char,
schar=ctypes.c_char,
byte=ctypes.c_byte,
ubyte=ctypes.c_ubyte,
wchar=ctypes.c_wchar,
short=ctypes.c_short,
ushort=ctypes.c_ushort,
int=ctypes.c_int,
uint=ctypes.c_uint,
long=ctypes.c_long,
ulong=ctypes.c_ulong,
longlong=ctypes.c_longlong,
ulonglong=ctypes.c_ulonglong,
float=ctypes.c_float,
double=ctypes.c_double,
longdouble=ctypes.c_longdouble,
voidptr=ctypes.c_void_p).items():
target_info.type_sizeof[tname] = ctypes.sizeof(ctype)
target_info.add_library('m')
target_info.add_library('stdio')
target_info.add_library('stdlib')
target_info.add_library('rbclib')
if use_tracing_allocator:
target_info.set('fn_allocate_varlen_buffer',
'rbclib_tracing_allocate_varlen_buffer')
target_info.set('fn_free_buffer', 'rbclib_tracing_free_buffer')
else:
target_info.set('fn_allocate_varlen_buffer',
'rbclib_allocate_varlen_buffer')
target_info.set('fn_free_buffer', 'rbclib_free_buffer')
cls._host_target_info_cache[key] = target_info
return target_info
def test_from_triple(self):
f = llvm.Target.from_triple
with self.assertRaises(RuntimeError) as cm:
f("foobar")
self.assertIn("No available targets are compatible with",
str(cm.exception))
triple = llvm.get_default_triple()
target = f(triple)
self.assertEqual(target.triple, triple)
target.close()
def test_get_process_triple(self):
triple = llvm.get_process_triple()
default = llvm.get_default_triple()
self.assertIsInstance(triple, str)
self.assertTrue(triple)
default_parts = default.split('-')
triple_parts = triple.split('-')
# Arch must be equal
self.assertEqual(default_parts[0], triple_parts[0])
def __init__(self, tree: Program, symbol_table: SymbolTable,
source_file: str) -> None:
llvm.initialize()
llvm.initialize_all_targets()
llvm.initialize_all_asmprinters()
self.tree = tree
self.codegen = CodeGenerator(symbol_table)
self.source_file = source_file
self.target = llvm.Target.from_triple(llvm.get_default_triple())
def __init__(self):
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
self.codegen = LLVMCodeGenerator()
self.codegen.module.triple = llvm.get_default_triple()
self.parser = Parser()
self._add_builtins(self.codegen.module)
self.target = llvm.Target.from_default_triple()
def codegen(ast, ir_flag=False):
ir_module = make_ir(ast)
if ir_flag:
return ir_module
else:
if binding.get_default_triple() != target_triple:
raise ValueError(
'cross-compilation not supported in code generator')
asm = make_asm(ir_module)
return asm
def visit_Program(self, node):
self._current_scope = node._scope
self.module = ir.Module()
self.module.triple = get_default_triple()
self.types = {
Integer(): ir.IntType(64),
Real(): ir.DoubleType(),
Logical(): ir.IntType(1),
}
int_type = ir.IntType(64)
fn = ir.FunctionType(int_type, [])
self.func = ir.Function(self.module, fn, name="main")
block = self.func.append_basic_block(name='.entry')
self.builder = ir.IRBuilder(block)
for ssym in self._current_scope.symbols:
assert ssym not in ["abs", "sqrt", "log", "sum", "random_number"]
sym = self._current_scope.symbols[ssym]
type_f = sym["type"]
if isinstance(type_f, Array):
assert len(type_f.shape) == 1
array_type = ir.ArrayType(self.types[type_f.type_],
type_f.shape[0])
ptr = self.builder.alloca(array_type, name=sym["name"])
else:
if type_f not in self.types:
raise Exception("Type not implemented.")
ptr = self.builder.alloca(self.types[type_f], name=sym["name"])
sym["ptr"] = ptr
self._global_scope.symbols["abs"][
"fn"] = self.module.declare_intrinsic('llvm.fabs',
[ir.DoubleType()])
self._global_scope.symbols["sqrt"][
"fn"] = self.module.declare_intrinsic('llvm.sqrt',
[ir.DoubleType()])
self._global_scope.symbols["log"][
"fn"] = self.module.declare_intrinsic('llvm.log',
[ir.DoubleType()])
fn_type = ir.FunctionType(
ir.DoubleType(),
[ir.IntType(64), ir.DoubleType().as_pointer()])
fn_sum = ir.Function(self.module, fn_type, name="_lfort_sum")
self._global_scope.symbols["sum"]["fn"] = fn_sum
fn_rand = ir.Function(self.module,
fn_type,
name="_lfort_random_number")
self._global_scope.symbols["random_number"]["fn"] = fn_rand
self.visit_sequence(node.contains)
self.visit_sequence(node.body)
self.builder.ret(ir.Constant(ir.IntType(64), 0))
self._current_scope = node._scope.parent_scope
def initialize():
'''
Initalize llvm and module
Return module
'''
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
module = ir.Module(name="prog")
module.triple = llvm.get_default_triple()
return module
def test_linux64_program_write(capfd):
source_ll = r"""
@.message = internal constant [14 x i8] c"Hello, world!\0A"
; write(STDOUT, message, message_len)
define i64 @write(i64 %STDOUT, i8* %message, i64 %message_len) {
%1 = call i64 asm sideeffect "syscall",
"={rax},{rax},{rdi},{rsi},{rdx},~{rcx},~{r11},~{dirflag},~{fpsr},~{flags}"
( i64 1 ; {rax} SYSCALL_WRITE
, i64 %STDOUT ; {rdi} STDOUT
, i8* %message ; {rsi} message
, i64 %message_len ; {rdx} message_len
)
ret i64 %1
}
; exit(int exit_code)
define void @exit(i64 %exit_code) {
call i64 asm sideeffect "syscall",
"={rax},{rax},{rdi},~{rcx},~{r11},~{dirflag},~{fpsr},~{flags}"
( i64 60 ; {rax} SYSCALL_EXIT
, i64 %exit_code ; {rdi} exit_code
)
ret void
}
define void @_start() {
%message_ptr = getelementptr [14 x i8], [14 x i8]* @.message , i64 0, i64 0
call i64 @write(i64 1, i8* %message_ptr, i64 14)
call void @exit(i64 42)
ret void
}
"""
with TemporaryDirectory() as tmpdir:
objfile = os.path.join(tmpdir, "test1.o")
binfile = os.path.join(tmpdir, "test1")
llvm.initialize()
llvm.initialize_native_asmprinter()
llvm.initialize_native_asmparser()
llvm.initialize_native_target()
target = llvm.Target.from_triple(llvm.get_default_triple())
target_machine = target.create_target_machine()
mod = llvm.parse_assembly(source_ll)
mod.verify()
with open(objfile, "wb") as o:
o.write(target_machine.emit_object(mod))
linker(["-o", binfile, objfile])
r = call("%s" % binfile)
assert r == 42
out = capfd.readouterr().out
assert out == "Hello, world!\n"
def pi_llvm(pi_ast):
module = ir.Module('main_module')
module.triple = llvm.get_default_triple()
func_type = ir.FunctionType(LLVMTypes.INT, [], False)
func = ir.Function(module, func_type, "main_function")
llvm_compiler = LLVMDcl(func)
llvm_compiler.compile(pi_ast)
llvm_compiler.builder.ret(llvm_compiler.compile(Num(0)))
return module
def test_linux64_program():
"""
This is the simplest assembly program that uses Linux 64bit syscall to
return an exit value.
"""
# Named registers are used in the `asm` block, so that LLVM handles
# register allocation.
#
# The calling convention for syscall on x86-64 (see `man syscall`) is to
# pass the system call number in {rax}, the return value is returned in
# {rax}, and the system call arguments in:
# {rdi},{rsi},{rdx},{r10},{r8},{r9}
# The syscall kernel call clobbers {rcx} and {r11} registers.
#
# The LLVM's `asm` call itself clobbers the following registers:
# * {flags} (EFLAGS: status flags register)
# * {dirflag} (DF: direction flag; modeled separately from {flags})
# * {fpsr} (floating point status register)
source_ll = r"""
; exit(int exit_code)
define void @exit(i64 %exit_code) {
call i64 asm sideeffect "syscall",
"={rax},{rax},{rdi},~{rcx},~{r11},~{dirflag},~{fpsr},~{flags}"
( i64 60 ; {rax} SYSCALL_EXIT
, i64 %exit_code ; {rdi} exit_code
)
ret void
}
define void @_start() {
call void @exit(i64 42)
ret void
}
"""
with TemporaryDirectory() as tmpdir:
objfile = os.path.join(tmpdir, "test1.o")
binfile = os.path.join(tmpdir, "test1")
llvm.initialize()
llvm.initialize_native_asmprinter()
llvm.initialize_native_asmparser()
llvm.initialize_native_target()
target = llvm.Target.from_triple(llvm.get_default_triple())
target_machine = target.create_target_machine()
mod = llvm.parse_assembly(source_ll)
mod.verify()
with open(objfile, "wb") as o:
o.write(target_machine.emit_object(mod))
linker(["-o", binfile, objfile])
r = call("%s" % binfile)
assert r == 42
def __init__(self, module_name):
self.module = ir.Module(module_name)
self.module.triple = binding.get_default_triple()
self.module.data_layout = ''
self.target_data = binding.create_target_data(self.module.data_layout)
self.builder = None
self.terminating_return = None
self.insert_blocks = []
self.fns = {}
self.vars = {}
self.nstrings = 0
self.zero = self.getint(0)
self.memset = None
self.loops = []
def initialize_module(self, name):
# create module
self.module = ir.Module(name=name)
self.module.triple = binding.get_default_triple()
# load builtin I/O functions
self.load_builtins()
# create main function
func_type = ir.FunctionType(ir.VoidType(), [], False)
base_func = ir.Function(self.module, func_type, name="main")
block = base_func.append_basic_block(name="entry")
# create llvm ir builder and set at start of the main block
self.builder = ir.IRBuilder(block)
def _test_record_args(self, revargs):
"""
Testing scalar record value as argument
"""
npval = self.refsample1d.copy()[0]
nbval = self.nbsample1d.copy()[0]
attrs = "abc"
valtypes = types.float64, types.int16, types.complex64
values = 1.23, 12345, 123 + 456j
old_refcnt = sys.getrefcount(nbval)
for attr, valtyp, val in zip(attrs, valtypes, values):
expected = getattr(npval, attr)
nbrecord = numpy_support.from_dtype(recordtype)
# Test with a record as either the first argument or the second
# argument (issue #870)
if revargs:
prefix = "get_record_rev_"
argtypes = (valtyp, nbrecord)
args = (val, nbval)
else:
prefix = "get_record_"
argtypes = (nbrecord, valtyp)
args = (nbval, val)
pyfunc = globals()[prefix + attr]
cfunc = self.get_cfunc(pyfunc, argtypes)
got = cfunc(*args)
try:
self.assertEqual(expected, got)
except AssertionError as e:
# On ARM, a LLVM misoptimization can produce buggy code,
# see https://llvm.org/bugs/show_bug.cgi?id=24669
import llvmlite.binding as ll
if attr != "c":
raise
if ll.get_default_triple() != "armv7l-unknown-linux-gnueabihf":
raise
self.assertEqual(val, got)
else:
self.assertEqual(nbval[attr], val)
del got, expected, args
# Check for potential leaks (issue #441)
self.assertEqual(sys.getrefcount(nbval), old_refcnt)
def _test_record_args(self, revargs):
"""
Testing scalar record value as argument
"""
npval = self.refsample1d.copy()[0]
nbval = self.nbsample1d.copy()[0]
attrs = "abc"
valtypes = types.float64, types.int16, types.complex64
values = 1.23, 12345, 123 + 456j
old_refcnt = sys.getrefcount(nbval)
for attr, valtyp, val in zip(attrs, valtypes, values):
expected = getattr(npval, attr)
nbrecord = numpy_support.from_dtype(recordtype)
# Test with a record as either the first argument or the second
# argument (issue #870)
if revargs:
prefix = "get_record_rev_"
argtypes = (valtyp, nbrecord)
args = (val, nbval)
else:
prefix = "get_record_"
argtypes = (nbrecord, valtyp)
args = (nbval, val)
pyfunc = globals()[prefix + attr]
cfunc = self.get_cfunc(pyfunc, argtypes)
got = cfunc(*args)
try:
self.assertEqual(expected, got)
except AssertionError:
# On ARM, a LLVM misoptimization can produce buggy code,
# see https://llvm.org/bugs/show_bug.cgi?id=24669
import llvmlite.binding as ll
if attr != "c":
raise
if ll.get_default_triple() != "armv7l-unknown-linux-gnueabihf":
raise
self.assertEqual(val, got)
else:
self.assertEqual(nbval[attr], val)
del got, expected, args
# Check for potential leaks (issue #441)
self.assertEqual(sys.getrefcount(nbval), old_refcnt)
def host(cls, name='host_cpu', strict=False):
"""Return target info for host CPU.
"""
key = (name, strict)
target_info = cls._host_target_info_cache.get(key)
if target_info is not None:
return target_info
import llvmlite.binding as ll
target_info = TargetInfo(name=name, strict=strict)
target_info.set('name', ll.get_host_cpu_name())
target_info.set('triple', ll.get_default_triple())
features = ','.join(['-+'[int(v)] + k
for k, v in ll.get_host_cpu_features().items()])
target_info.set('features', features)
for tname, ctype in dict(
bool=ctypes.c_bool,
size_t=ctypes.c_size_t,
ssize_t=ctypes.c_ssize_t,
char=ctypes.c_char,
uchar=ctypes.c_char,
schar=ctypes.c_char,
byte=ctypes.c_byte,
ubyte=ctypes.c_ubyte,
wchar=ctypes.c_wchar,
short=ctypes.c_short,
ushort=ctypes.c_ushort,
int=ctypes.c_int,
uint=ctypes.c_uint,
long=ctypes.c_long,
ulong=ctypes.c_ulong,
longlong=ctypes.c_longlong,
ulonglong=ctypes.c_ulonglong,
float=ctypes.c_float,
double=ctypes.c_double,
longdouble=ctypes.c_longdouble,
).items():
target_info.type_sizeof[tname] = ctypes.sizeof(ctype)
cls._host_target_info_cache[key] = target_info
return target_info
def make_asm(ir_module):
# Note: llvmlite does not allow us to do cross-compilation
# only native compilation is supported.
# therefore, only use default triple for native code generation
binding.initialize()
binding.initialize_native_target()
binding.initialize_native_asmprinter()
target = binding.Target.from_triple(binding.get_default_triple())
target_machine = target.create_target_machine()
target_machine.set_asm_verbosity(True)
# necessary in order to generate code from ir module
mod_ref = binding.parse_assembly(ir_module)
mod_ref.verify()
# generate the native assembly code
asm_code = target_machine.emit_assembly(mod_ref)
# return asm code as a string
return asm_code
def main(verbose=True):
llvm.initialize()
llvm.initialize_native_asmprinter()
llvm.initialize_native_target()
target = llvm.Target.from_triple(llvm.get_default_triple())
target_machine = target.create_target_machine()
target_machine.set_asm_verbosity(True)
# Empty backing module
backing_mod = llvm.parse_assembly("")
backing_mod.verify()
engine = llvm.create_mcjit_compiler(backing_mod, target_machine)
print("Interactive Fortran.")
print(" * Use Ctrl-D to exit.")
print(" * Use Enter to submit.")
print(" * Features:")
print(" - Multi-line editing (use Alt-Enter)")
print(" - History")
print(" - Syntax highlighting")
print()
fortran_evaluator = FortranEvaluator()
session = PromptSession('> ',
lexer=PygmentsLexer(FortranLexer),
multiline=True,
key_bindings=kb)
try:
while True:
text = session.prompt()
if verbose:
print()
handle_input(engine, fortran_evaluator, text, verbose)
if verbose:
print()
except EOFError:
print("Exiting.")
def run_code(code):
compiler = Compiler()
lexer = PLexer()
tokens = lexer.tokenize(code)
parser = PParser()
parser.parse(tokens)
ast = parser.ast
ast = ast[1]['body']
#print(pprint.pformat(ast))
compiler.compile(ast)
module = compiler.module
module.triple = llvm.get_default_triple()
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
llvm_ir_parsed = llvm.parse_assembly(str(module))
llvm_ir_parsed.verify()
target_machine = llvm.Target.from_default_triple().create_target_machine()
engine = llvm.create_mcjit_compiler(llvm_ir_parsed, target_machine)
engine.finalize_object()
# Run the function with name func_name. This is why it makes sense to have a 'main' function that calls other functions.
entry = engine.get_function_address('main')
cfunc = CFUNCTYPE(c_int)(entry)
print('The llvm IR generated is:')
print(module)
print()
start_time = time()
result = cfunc()
end_time = time()
print(f'It returns {result}')
print('\nExecuted in {:f} sec'.format(end_time - start_time))
def test_name(self):
t = llvm.Target.from_triple(llvm.get_default_triple())
u = llvm.Target.from_default_triple()
self.assertIsInstance(t.name, str)
self.assertEqual(t.name, u.name)
from llvmlite import binding as llvm
from llvmlite import ir as lc
llvm.initialize()
llvm.initialize_native_target()
llvm.initialize_native_asmprinter()
mod = lc.Module()
mod.triple = llvm.get_default_triple()
func = lc.Function(mod, lc.FunctionType(lc.VoidType(), [lc.IntType(32)]),
name='foo')
builder = lc.IRBuilder(func.append_basic_block())
builder.ret_void()
print(mod)
mod = llvm.parse_assembly(str(mod))
mod.verify()
print(repr(mod))
print(mod)
with llvm.create_module_pass_manager() as pm:
with llvm.create_pass_manager_builder() as pmb:
pmb.populate(pm)
pm.run(mod)
print(mod)
tm = llvm.Target.from_default_triple().create_target_machine()
ee = llvm.create_mcjit_compiler(mod, tm)
def __init__(self):
self.stack = []
self._mark = []
self.symboltable = builtins()
self.module = ir.Module(name="main")
self.module.triple = binding.get_default_triple()
def test_triple(self):
mod = self.module()
s = mod.triple
self.assertEqual(s, llvm.get_default_triple())
mod.triple = ''
self.assertEqual(mod.triple, '')
def codeGenerate(self,var_ptr_symbolTBL):
module = ll.Module()
module.triple = llvm.get_default_triple()
for ast in self.asts:
module = ast.codeGenerate(module, var_ptr_symbolTBL)
return module, cfg_list;
def test_get_default_triple(self):
triple = llvm.get_default_triple()
self.assertIsInstance(triple, str)
self.assertTrue(triple)
def tli(self):
return llvm.create_target_library_info(llvm.get_default_triple())
def test_str(self):
target = llvm.Target.from_triple(llvm.get_default_triple())
s = str(target)
self.assertIn(target.name, s)
self.assertIn(target.description, s)
def _create_empty_module(self, name):
ir_module = lc.Module.new(name)
ir_module.triple = ll.get_default_triple()
if self._data_layout:
ir_module.data_layout = self._data_layout
return ir_module
def _create_empty_module(self, name):
ir_module = lc.Module.new(name)
ir_module.triple = ll.get_default_triple()
return ir_module
def __init__(self, modulename):
self.module = ir.Module(name=modulename)
self.module.triple = llvm.get_default_triple()
self.currentfunc = None
def test_create_target_library_info(self):
tli = llvm.create_target_library_info(llvm.get_default_triple())
with tli:
pass
tli.close()
def test_description(self):
t = llvm.Target.from_triple(llvm.get_default_triple())
u = llvm.Target.from_default_triple()
self.assertIsInstance(t.description, str)
self.assertEqual(t.description, u.description)
def module(self, asm=asm_sum, context=None):
asm = asm.format(triple=llvm.get_default_triple())
mod = llvm.parse_assembly(asm, context)
return mod
def test_create_target_machine(self):
target = llvm.Target.from_triple(llvm.get_default_triple())
target.create_target_machine('', '', 1, 'default', 'default')
