def test_str(self):
"""
Test the string representation of types.
"""
self.assertEqual(str(int1), 'i1')
self.assertEqual(str(ir.IntType(29)), 'i29')
self.assertEqual(str(flt), 'float')
self.assertEqual(str(dbl), 'double')
self.assertEqual(str(ir.VoidType()), 'void')
self.assertEqual(str(ir.FunctionType(int1, ())), 'i1 ()')
self.assertEqual(str(ir.FunctionType(int1, (flt,))), 'i1 (float)')
self.assertEqual(str(ir.FunctionType(int1, (flt, dbl))),
'i1 (float, double)')
self.assertEqual(str(ir.FunctionType(int1, (), var_arg=True)),
'i1 (...)')
self.assertEqual(str(ir.FunctionType(int1, (flt,), var_arg=True)),
'i1 (float, ...)')
self.assertEqual(str(ir.FunctionType(int1, (flt, dbl), var_arg=True)),
'i1 (float, double, ...)')
self.assertEqual(str(ir.PointerType(int32)), 'i32*')
self.assertEqual(str(ir.PointerType(ir.PointerType(int32))), 'i32**')
self.assertEqual(str(ir.ArrayType(int1, 5)), '[5 x i1]')
self.assertEqual(str(ir.ArrayType(ir.PointerType(int1), 5)), '[5 x i1*]')
self.assertEqual(str(ir.PointerType(ir.ArrayType(int1, 5))), '[5 x i1]*')
self.assertEqual(str(ir.LiteralStructType((int1,))), '{i1}')
self.assertEqual(str(ir.LiteralStructType((int1, flt))), '{i1, float}')
self.assertEqual(str(ir.LiteralStructType((
ir.PointerType(int1), ir.LiteralStructType((int32, int8))))),
'{i1*, {i32, i8}}')
# Avoid polluting the namespace
context = ir.Context()
mytype = context.get_identified_type("MyType")
self.assertEqual(str(mytype), "%MyType")
def test_gep(self):
def check_constant(tp, i, expected):
actual = tp.gep(ir.Constant(int32, i))
self.assertEqual(actual, expected)
def check_index_type(tp):
index = ir.Constant(dbl, 1.0)
with self.assertRaises(TypeError):
tp.gep(index)
tp = ir.PointerType(dbl)
for i in range(5):
check_constant(tp, i, dbl)
check_index_type(tp)
tp = ir.ArrayType(int1, 3)
for i in range(3):
check_constant(tp, i, int1)
check_index_type(tp)
tp = ir.LiteralStructType((dbl, ir.LiteralStructType((int1, int8))))
check_constant(tp, 0, dbl)
check_constant(tp, 1, ir.LiteralStructType((int1, int8)))
with self.assertRaises(IndexError):
tp.gep(ir.Constant(int32, 2))
check_index_type(tp)
context = ir.Context()
tp = ir.IdentifiedStructType(context, "MyType")
tp.set_body(dbl, ir.LiteralStructType((int1, int8)))
check_constant(tp, 0, dbl)
check_constant(tp, 1, ir.LiteralStructType((int1, int8)))
with self.assertRaises(IndexError):
tp.gep(ir.Constant(int32, 2))
check_index_type(tp)
def __init__(self):
# TODO: come up with a less naive way of handling the symtab and types
self.classes = None
self.symtab = {}
self.typetab = {}
self.is_break = False
self.current_class = None
self.loop_end_blocks = []
self.loop_cond_blocks = []
context = ir.Context()
self.module = Module(name='opal-lang', context=context)
self.blocks = []
self.scope = {}
self._add_builtins()
func_ty = ir.FunctionType(ir.VoidType(), [])
func = Function(self.module, func_ty, 'main')
self.current_function = func
entry_block = self.add_block('entry')
exit_block = self.add_block('exit')
self.function_stack = [func]
self.builder = Builder(entry_block)
self.exit_blocks = [exit_block]
self.block_stack = [entry_block]
def _config_llvm(self):
self.module = ir.Module(name='main_module', context=ir.Context())
self.module.triple = self.binding.get_default_triple()
func_type = ir.FunctionType(ir.IntType(64), [], False)
main_func = ir.Function(self.module, func_type, name='main')
block = main_func.append_basic_block(name='entry')
self.builder = ir.IRBuilder(block)
def test_target_data_non_default_context(self):
context = ir.Context()
mytype = context.get_identified_type("MyType")
mytype.elements = [ir.IntType(32)]
module = ir.Module(context=context)
td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
self.assertEqual(mytype.get_abi_size(td, context=context), 4)
def __init__(self, name: str):
# create llvm module
self.__llvm_module = ir.Module(name, context=ir.Context())
self.__llvm_module.triple = binding.Target.from_default_triple().triple
self.__llvm_ref = None
self.__is_normalize = True
self.__llvm_types = LazyDictionary[Type, ir.Type](constructor=self.declare_type, initializer=self.emit_type)
self.__llvm_functions = LazyDictionary[Function, ir.Function](constructor=self.declare_function)
def test_identified_struct(self):
context = ir.Context()
mytype = context.get_identified_type("MyType")
module = ir.Module(context=context)
self.assertTrue(mytype.is_opaque)
self.assert_valid_ir(module)
oldstr = str(module)
mytype.set_body(ir.IntType(32), ir.IntType(64), ir.FloatType())
self.assertFalse(mytype.is_opaque)
self.assert_valid_ir(module)
self.assertNotEqual(oldstr, str(module))
#/usr/bin/env python3
import llvmlite.ir as ll
import llvmlite.binding as llvm
llvm.initialize()
llvm.initialize_native_target()
context = ll.Context()
module = ll.Module(context=context)
module.triple = llvm.get_default_triple()
my_type2 = context.get_identified_type("MyType2")
a_type = ll.LiteralStructType((ll.FloatType(), ll.IntType(1)), packed=True)
my_type2.set_body(ll.FloatType(),
ll.IntType(32)) # setting %"MyType2" = type {float, i32}
# module.add_global(my_type2)
print(module)
def __init__(self):
self.llcontext = ll.Context()