def __init__(self, dmm, fe_type):
super(GeneratorModel, self).__init__(dmm, fe_type)
# XXX Fold this in DataPacker?
self._arg_models = [
self._dmm.lookup(t) for t in fe_type.arg_types
if not isinstance(t, types.Omitted)
]
self._state_models = [self._dmm.lookup(t) for t in fe_type.state_types]
self._args_be_type = ir.LiteralStructType(
[t.get_data_type() for t in self._arg_models])
self._state_be_type = ir.LiteralStructType(
[t.get_data_type() for t in self._state_models])
# The whole generator closure
self._be_type = ir.LiteralStructType([
self._dmm.lookup(types.int32).get_value_type(), self._args_be_type,
self._state_be_type
])
self._be_ptr_type = self._be_type.as_pointer()
def make_anonymous_struct(builder, values, struct_type=None):
"""
Create an anonymous struct containing the given LLVM *values*.
"""
if struct_type is None:
struct_type = ir.LiteralStructType([v.type for v in values])
struct_val = struct_type(ir.Undefined)
for i, v in enumerate(values):
struct_val = builder.insert_value(struct_val, v, i)
return struct_val
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\"")
mytype1 = context.get_identified_type("MyType\\")
self.assertEqual(str(mytype1), "%\"MyType\\5c\"")
mytype2 = context.get_identified_type("MyType\"")
self.assertEqual(str(mytype2), "%\"MyType\\22\"")
def union(self, union: Union, depth=0) -> Any:
types = {}
for i, m in enumerate(union.members):
members = [
ir.IntType(32),
self.visit(m.type, depth + 1, mode='type')
]
types[m.name] = (i, ir.LiteralStructType(elems=members))
return types
def ptx_match_all_sync(context, builder, sig, args):
mask, value = args
width = sig.args[1].bitwidth
if sig.args[1] in types.real_domain:
value = builder.bitcast(value, ir.IntType(width))
fname = 'llvm.nvvm.match.all.sync.i{}'.format(width)
lmod = builder.module
fnty = ir.FunctionType(
ir.LiteralStructType((ir.IntType(32), ir.IntType(1))),
(ir.IntType(32), ir.IntType(width)))
func = cgutils.get_or_insert_function(lmod, fnty, fname)
return builder.call(func, (mask, value))
def test_abi_alignment(self):
td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
def check(tp, expected):
self.assertIn(tp.get_abi_alignment(td), expected)
check(int8, (1, 2, 4))
check(int32, (4, ))
check(int64, (8, ))
check(ir.ArrayType(int8, 5), (1, 2, 4))
check(ir.ArrayType(int32, 5), (4, ))
check(ir.LiteralStructType((dbl, flt, flt)), (8, ))
def test_abi_size(self):
td = llvm.create_target_data("e-m:e-i64:64-f80:128-n8:16:32:64-S128")
def check(tp, expected):
self.assertEqual(tp.get_abi_size(td), expected)
check(int8, 1)
check(int32, 4)
check(int64, 8)
check(ir.ArrayType(int8, 5), 5)
check(ir.ArrayType(int32, 5), 20)
check(ir.LiteralStructType((dbl, flt, flt)), 16)
def visit_Tuple(self, node):
elements = (self.visit(element) for element in node.elts)
element_values = [self.builder.load(element) if helpers.is_pointer(element) else element for element in elements]
element_types = [element.type for element in element_values]
if len(element_types) > 0 and all(x == element_types[0] for x in element_types):
result = ir.ArrayType(element_types[0], len(element_types))(ir.Undefined)
else:
result = ir.LiteralStructType(element_types)(ir.Undefined)
for i, val in enumerate(element_values):
result = self.builder.insert_value(result, val, i)
return result
def convert_python_struct_to_llvm_ir(self, t):
self._stats["types_converted"] += 1
if t is None:
return ir.LiteralStructType([])
elif type(t) is list:
if len(t) == 0:
return ir.LiteralStructType([])
elems_t = [self.convert_python_struct_to_llvm_ir(x) for x in t]
if all(x == elems_t[0] for x in elems_t):
return ir.ArrayType(elems_t[0], len(elems_t))
return ir.LiteralStructType(elems_t)
elif type(t) is tuple:
elems_t = [self.convert_python_struct_to_llvm_ir(x) for x in t]
if len(elems_t) > 0 and all(x == elems_t[0] for x in elems_t):
return ir.ArrayType(elems_t[0], len(elems_t))
return ir.LiteralStructType(elems_t)
elif isinstance(t, enum.Enum):
# FIXME: Consider enums of non-int type
assert all(round(x.value) == x.value for x in type(t))
return self.int32_ty
elif isinstance(t, (int, float, np.floating)):
return self.float_ty
elif isinstance(t, np.integer):
# Python 'int' is handled above as it is the default type for '0'
return ir.IntType(t.nbytes * 8)
elif isinstance(t, np.ndarray):
return self.convert_python_struct_to_llvm_ir(t.tolist())
elif isinstance(t, np.random.RandomState):
return pnlvm.builtins.get_mersenne_twister_state_struct(self)
elif isinstance(t, Time):
return ir.ArrayType(self.int32_ty, len(TimeScale))
elif isinstance(t, SampleIterator):
if isinstance(t.generator, list):
return ir.ArrayType(self.float_ty, len(t.generator))
# Generic iterator is {start, increment, count}
return ir.LiteralStructType(
(self.float_ty, self.float_ty, self.int32_ty))
assert False, "Don't know how to convert {}".format(type(t))
def test_comparisons(self):
# A bunch of mutually unequal types
types = [
ir.LabelType(),
ir.VoidType(),
ir.FunctionType(int1, (int8, int8)),
ir.FunctionType(int1, (int8, )),
ir.FunctionType(int1, (int8, ), var_arg=True),
ir.FunctionType(int8, (int8, )),
int1,
int8,
int32,
flt,
dbl,
ir.ArrayType(flt, 5),
ir.ArrayType(dbl, 5),
ir.ArrayType(dbl, 4),
ir.LiteralStructType((int1, int8)),
ir.LiteralStructType((int8, int1)),
]
types.extend([
ir.PointerType(tp) for tp in types
if not isinstance(tp, ir.VoidType)
])
for a, b in itertools.product(types, types):
if a is not b:
self.assertFalse(a == b, (a, b))
self.assertTrue(a != b, (a, b))
# We assume copy.copy() works fine here...
for tp in types:
other = copy.copy(tp)
self.assertIsNot(other, tp)
if isinstance(tp, ir.LabelType):
self.assertFalse(tp == other, (tp, other))
self.assertTrue(tp != other, (tp, other))
else:
self.assertTrue(tp == other, (tp, other))
self.assertFalse(tp != other, (tp, other))
def _param_struct(p):
val = p.get(None) # this should use defaults
if hasattr(val, "_get_compilation_params") or \
hasattr(val, "_get_param_struct_type"):
return self.get_param_struct_type(val)
if isinstance(val, ContentAddressableList):
return ir.LiteralStructType(self.get_param_struct_type(x) for x in val)
elif p.name == 'matrix': # Flatten matrix
val = np.asfarray(val).flatten()
elif p.name == 'num_estimates': # Should always be int
val = np.int32(0) if val is None else np.int32(val)
elif np.ndim(val) == 0 and component._is_param_modulated(p):
val = [val] # modulation adds array wrap
return self.convert_python_struct_to_llvm_ir(val)
def make_ir_type(self, compiler):
if not self.fields:
raise CodegenError("type {} has no defined field.".format(
self.name))
else:
elems = []
for field in self.fields:
try:
field_type = compiler.types[field.type]
except KeyError:
raise CodegenError("unknown field type: {}".format(
field.type))
elems.append(field_type.ir_type)
self.ir_type = ir.LiteralStructType(elems)
def __init__(self, target, machine):
# Record target and machine
self.target = target
self.machine = machine
# We choose the word type to be an integer with the same size as a
# pointer to i8. The word size is expressed in bytes
word_size = ir.IntType(8).as_pointer().get_abi_size(
self.machine.target_data)
# Define the word type and bytes-per-word appropriately
self.word_type = ir.IntType(word_size * 8)
self.bytes_per_word = word_size
# Define the type used for constructor function records
priority_type = ir.IntType(32)
ctor_func_type = ir.FunctionType(ir.VoidType(), [])
data_ptr_type = ir.PointerType(ir.IntType(8))
self.ctor_record_type = ir.LiteralStructType(
[priority_type,
ctor_func_type.as_pointer(), data_ptr_type])
# Initialise context attributes
self.module = None
self.global_scope = {}
self.externals = {}
self.scope = collections.ChainMap(self.global_scope)
self.builder = None
self.string_constants = {}
self.ctor_records = []
# Block at end of current switch/which statement
self.break_block = None
# LLVM Value of condition in current switch statement
self.switch_val = None
# Block which new switch tests should be appended to
self.switch_block = None
# Labels are mappings from names to.basic blocks A goto branches to the
# block. The labels dict is only created within functions.
self.labels = None
# Callables which should be called after all code has been emitted
self.post_emit_hooks = []
# Flag to indicate when one is within the emitting_code() context.
self._is_emitting = False
def declare_type(self, symbol: Type) -> ir.Type:
if symbol.is_generic:
raise DiagnosticError(symbol.location, f'Conversion to LLVM for generic type is not allowed')
if isinstance(symbol, BooleanType):
return ir.IntType(1)
elif isinstance(symbol, IntegerType):
return ir.IntType(64)
elif isinstance(symbol, VoidType):
return ir.LiteralStructType([])
elif isinstance(symbol, VoidType):
return ir.LiteralStructType([])
elif isinstance(symbol, StringType):
return ir.IntType(8).as_pointer()
elif isinstance(symbol, ClassType):
return self.llvm_context.get_identified_type(symbol.mangled_name).as_pointer()
elif isinstance(symbol, ArrayType):
# {size_t, T*}
llvm_size = self.llvm_size
llvm_element = self.llvm_types[symbol.element_type]
llvm_array = llvm_element.as_pointer()
return ir.LiteralStructType([llvm_size, llvm_array]).as_pointer()
raise DiagnosticError(symbol.location, f'Conversion to LLVM is not implemented: {type(symbol).__name__}')
def get_state_struct_type(self, component):
self._stats["state_structs_generated"] += 1
if hasattr(component, '_get_state_struct_type'):
return component._get_state_struct_type(self)
def _state_struct(p):
val = p.get(None) # this should use defaults
if hasattr(val, "_get_compilation_state") or \
hasattr(val, "_get_state_struct_type"):
return self.get_state_struct_type(val)
if isinstance(val, ContentAddressableList):
return ir.LiteralStructType(self.get_state_struct_type(x) for x in val)
struct = self.convert_python_struct_to_llvm_ir(val)
return ir.ArrayType(struct, p.history_min_length + 1)
elements = map(_state_struct, component._get_compilation_state())
return ir.LiteralStructType(elements)
def visit_vardecl(self, node):
typ = type_map[node.type.value] if node.type.value in type_map else self.search_scopes(node.type.value)
if node.type.value == FUNC:
if node.type.func_ret_type.value in type_map:
func_ret_type = type_map[node.type.func_ret_type.value]
else:
func_ret_type = self.search_scopes(node.type.func_ret_type.value)
func_parameters = self.get_args(node.type.func_params)
func_ty = ir.FunctionType(func_ret_type, func_parameters, None).as_pointer()
typ = func_ty
self.alloc_and_define(node.value.value, typ)
elif node.type.value in (LIST, TUPLE):
array_type = node.type.func_params['0'].value
typ = ir.LiteralStructType([type_map[INT], type_map[INT], type_map[array_type].as_pointer()])
self.alloc_and_define(node.value.value, typ)
else:
self.alloc_and_define(node.value.value, typ)
def var_decl(self, node):
namelist = self.name_list(node.children[0])
if (node.children[2].children[0].type == "simple_type_decl"):
ir_type = self.type_decl(node.children[2])
for name in namelist:
# addr = self.builder.alloca(ir_type)
# # addr = ir.GlobalVariable(self.module, ir_type, node.children[0].children[0].name)
# # addr.initializer = ir.Constant(ir.IntType(32), 0)
# self.symbol_table.insert([name, addr])
if len(self.symbol_table.tables) > 1:
addr = self.builder.alloca(ir_type)
else:
addr = ir.GlobalVariable(self.module, ir_type, name)
if ir_type.intrinsic_name == 'i32':
addr.initializer = ir.Constant(ir.IntType(32), 0)
elif ir_type.intrinsic_name == 'f64':
addr.initializer = ir.Constant(ir.DoubleType(), 0)
elif ir_type.intrinsic_name == 'i8':
addr.initializer = ir.Constant(ir.IntType(8), 0)
self.symbol_table.insert([name, addr])
elif (node.children[2].children[0].type == "array_type_decl"):
array_list = self.type_decl(node.children[2])
array_type = ir.ArrayType(array_list[1],
int(array_list[2]) +
1) # x integers of element
for name in namelist:
addr = self.builder.alloca(array_type) # pointer to array
self.symbol_table.insert([name, addr])
elif (node.children[2].children[0].type == "record_type_decl"):
field_list = self.type_decl(node.children[2])
i32 = ir.IntType(32)
for name in namelist:
field_body = [i32]
count = 1
for f in field_list[1]:
field_body += [f[1]]
index = ir.Constant(i32, count)
try:
self.symbol_table.insert([name + "." + f[0], index], 0)
except MultiDefinedError as error:
pass
count += 1
str_list = ir.LiteralStructType(field_body)
addr = self.builder.alloca(str_list) # pointer to array
self.symbol_table.insert([name, addr])
def AddItem(self, Name, MemberList, TypeList):
'''
描述：添加一个元素
参数：名称，成员列表，类型列表
返回：成功{"result":"success"}，失败{"result":"fail","reason":具体原因码}
'''
#todo:处理这个错误
if Name in self.List:
Result = {
"result": "fail",
"reason": Constants.ERROR_TYPE_REDEFINATION
}
return Result
NewStruct = {}
NewStruct["Members"] = MemberList
NewStruct["Type"] = ir.LiteralStructType(TypeList)
self.List[Name] = NewStruct
return {"result": "success"}
def ptx_shfl_sync_i32(context, builder, sig, args):
"""
The NVVM intrinsic for shfl only supports i32, but the cuda intrinsic
function supports both 32 and 64 bit ints and floats, so for feature parity,
i64, f32, and f64 are implemented. Floats by way of bitcasting the float to
an int, then shuffling, then bitcasting back. And 64-bit values by packing
them into 2 32bit values, shuffling thoose, and then packing back together.
"""
mask, mode, value, index, clamp = args
value_type = sig.args[2]
if value_type in types.real_domain:
value = builder.bitcast(value, ir.IntType(value_type.bitwidth))
fname = 'llvm.nvvm.shfl.sync.i32'
lmod = builder.module
fnty = ir.FunctionType(
ir.LiteralStructType((ir.IntType(32), ir.IntType(1))),
(ir.IntType(32), ir.IntType(32), ir.IntType(32),
ir.IntType(32), ir.IntType(32))
)
func = cgutils.get_or_insert_function(lmod, fnty, fname)
if value_type.bitwidth == 32:
ret = builder.call(func, (mask, mode, value, index, clamp))
if value_type == types.float32:
rv = builder.extract_value(ret, 0)
pred = builder.extract_value(ret, 1)
fv = builder.bitcast(rv, ir.FloatType())
ret = cgutils.make_anonymous_struct(builder, (fv, pred))
else:
value1 = builder.trunc(value, ir.IntType(32))
value_lshr = builder.lshr(value, context.get_constant(types.i8, 32))
value2 = builder.trunc(value_lshr, ir.IntType(32))
ret1 = builder.call(func, (mask, mode, value1, index, clamp))
ret2 = builder.call(func, (mask, mode, value2, index, clamp))
rv1 = builder.extract_value(ret1, 0)
rv2 = builder.extract_value(ret2, 0)
pred = builder.extract_value(ret1, 1)
rv1_64 = builder.zext(rv1, ir.IntType(64))
rv2_64 = builder.zext(rv2, ir.IntType(64))
rv_shl = builder.shl(rv2_64, context.get_constant(types.i8, 32))
rv = builder.or_(rv_shl, rv1_64)
if value_type == types.float64:
rv = builder.bitcast(rv, ir.DoubleType())
ret = cgutils.make_anonymous_struct(builder, (rv, pred))
return ret
def create_in_global_ctor(self):
current_block = self.current_block
current_func = self.current_func
current_struct = self.current_struct
conditional_block = self.conditional_block
end_block = self.end_block
pos = self.builder is not None and self.builder._anchor or 0
func = ParserState.module().get_global_safe('global_ctor')
if func is None:
func_type = self.create_function_type(ir.VoidType(), [], False)
func = self.create_function_with_type('global_ctor', 'global_ctor', func_type, "internal", "ccc",
FunctionDefinition('void'))
self.create_function_body(func, [])
struct_type = ir.LiteralStructType([ir.IntType(32), func_type.as_pointer(), ir.IntType(8).as_pointer()])
glob_value = ir.Constant(ir.ArrayType(struct_type, 1), [ir.Constant.literal_struct(
[ir.Constant(ir.IntType(32), 65535), func, NULL])])
glob_type = ir.ArrayType(struct_type, 1)
self.gen_global("llvm.global_ctors", glob_value, glob_type, RIALAccessModifier.PRIVATE, "appending", False)
else:
self.builder.position_before(func.entry_basic_block.terminator)
self.current_func = func
self.current_block = create_llvm_block(func.entry_basic_block)
self.current_struct = None
self.conditional_block = None
self.end_block = None
yield
self.finish_current_block()
self.finish_current_func()
self.current_block = current_block
self.current_func = current_func
self.current_struct = current_struct
self.conditional_block = conditional_block
self.end_block = end_block
self.builder._anchor = pos
self.builder._block = self.current_block is not None and self.current_block.block or None
return
def visit_Tuple(self, node):
elements = [self.visit(element) for element in node.elts]
elements = [
self.builder.load(element)
if helpers.is_pointer(element) else element for element in elements
]
element_types = [element.type for element in elements]
ret_list = self.builder.alloca(ir.LiteralStructType(element_types))
for idx, element in enumerate(elements):
self.builder.store(
element,
self.builder.gep(
ret_list, [self.ctx.int32_ty(0),
self.ctx.int32_ty(idx)]))
return ret_list
def define_dynamic_array(compiler):
# define a struct dynamic_array
# 0: int size
# 1: int capacity
# 2: int *data TODO: maybe make this a void pointer to allow any kind of data
dyn_array_struct = ir.LiteralStructType(
[type_map[INT], type_map[INT], type_map[INT].as_pointer()])
compiler.define('Dynamic_Array', dyn_array_struct)
dyn_array_struct_ptr = dyn_array_struct.as_pointer()
dynamic_array_init(compiler, dyn_array_struct_ptr)
dynamic_array_double_if_full(compiler, dyn_array_struct_ptr)
dynamic_array_append(compiler, dyn_array_struct_ptr)
dynamic_array_get(compiler, dyn_array_struct_ptr)
dynamic_array_set(compiler, dyn_array_struct_ptr)
dynamic_array_length(compiler, dyn_array_struct_ptr)
define_create_range(compiler, dyn_array_struct_ptr)
define_int_to_str(compiler, dyn_array_struct_ptr)
define_bool_to_str(compiler, dyn_array_struct_ptr)
define_print(compiler, dyn_array_struct_ptr)
def visitStructDeclaration(self,
ctx: c2llvmParser.StructDeclarationContext):
self.enter_scope()
struct_name = ctx.getChild(0).getChild(1).getText()
if struct_name in self.structures:
logger.error("Struct Declaration Error")
return
member_types = []
member_names = []
for index in range(2, ctx.getChildCount() - 2):
v_types, v_names = self.visit(ctx.getChild(index))
member_types.extend(v_types)
member_names.extend(v_names)
self.structures[struct_name] = {
'members': member_names,
'struct': ir.LiteralStructType(member_types)
}
self.exit_scope()
def type_definition(self, node):
name = node.children[0].name
if (node.children[2].children[0].type == "array_type_decl"):
array_list = self.type_decl(node.children[2])
array_type = ir.ArrayType(array_list[1],
int(array_list[2]) +
1) # x integers of element
addr = self.builder.alloca(array_type) # pointer to array
self.symbol_table.insert([name, addr])
elif (node.children[2].children[0].type == "record_type_decl"):
field_list = self.type_decl(node.children[2])
i32 = ir.IntType(32)
field_body = [i32]
count = 1
for f in field_list[1]:
field_body += [f[1]]
index = ir.Constant(i32, count)
self.symbol_table.insert([name + "." + f[0], index])
count += 1
str_list = ir.LiteralStructType(field_body)
addr = self.builder.alloca(str_list) # pointer to array
self.symbol_table.insert([name, addr])
def get_lpad(func):
global pad_map, block_num
if except_stack[-1] in pad_map:
return pad_map[except_stack[-1]]
lpad = func.append_basic_block(name="lpad" + str(block_num+1))
block_num +=1
lbuilder = ir.IRBuilder(lpad)
lp = lbuilder.landingpad(ir.LiteralStructType([int8.as_pointer(),int64]), 'lp')
lp.add_clause(ir.CatchClause(int8.as_pointer()(None)))
lbuilder.call(begin_catch,[])
lbuilder.call(end_catch,[])
rpad = func.append_basic_block(name="lpad" + str(block_num+1) + "_tgt")
lbuilder.branch(rpad)
rbuilder = ir.IRBuilder(rpad)
#lbuilder.call(resume,[lbuilder.extract_value(lp, 0)])
#lbuilder.resume(lp)
pad_map[except_stack[-1]] = (lpad,lbuilder,rpad,rbuilder)
return pad_map[except_stack[-1]]
def create_in_global_ctor(self):
func = self.get_global_safe('global_ctor')
if func is None:
func_type = ir.FunctionType(ir.VoidType(), [], False)
func = self.declare_function('global_ctor', 'global_ctor',
func_type, "internal", "ccc",
FunctionDefinition("Void"))
struct_type = ir.LiteralStructType(
[Int32,
func_type.as_pointer(),
ir.IntType(8).as_pointer()])
glob_value = ir.Constant(
ir.ArrayType(struct_type, 1),
[ir.Constant.literal_struct([Int32(65535), func, NULL])])
glob_type = ir.ArrayType(struct_type, 1)
self.declare_global("llvm.global_ctors",
map_llvm_to_type(glob_type), glob_type,
"appending", glob_value)
with self.create_or_enter_function_body(func):
yield
def define_builtins(self):
# 0: int size
# 1: int capacity
# 2: int *data
str_struct = ir.LiteralStructType(
[type_map[INT], type_map[INT], type_map[INT].as_pointer()])
self.define('Str', str_struct)
str_struct_ptr = str_struct.as_pointer()
self.define('Str_ptr', str_struct_ptr)
type_map[STR] = str_struct
lint = str(type_map[INT])
dynamic_array_init(self, str_struct_ptr, lint)
dynamic_array_double_if_full(self, str_struct_ptr, lint)
dynamic_array_append(self, str_struct_ptr, lint)
dynamic_array_get(self, str_struct_ptr, lint)
dynamic_array_set(self, str_struct_ptr, lint)
dynamic_array_length(self, str_struct_ptr, lint)
define_create_range(self, str_struct_ptr, lint)
define_int_to_str(self, str_struct_ptr)
define_bool_to_str(self, str_struct_ptr)
define_print(self, str_struct_ptr)
def codegen(context, builder, sig, args):
vtablety = ir.LiteralStructType([
ll_voidptr_type, # item incref
ll_voidptr_type, # item decref
])
setmethod_fnty = ir.FunctionType(
ir.VoidType(),
[ll_list_type, vtablety.as_pointer()]
)
setmethod_fn = ir.Function(
builder.module,
setmethod_fnty,
name='numba_list_set_method_table',
)
dp = args[0]
vtable = cgutils.alloca_once(builder, vtablety, zfill=True)
# install item incref/decref
item_incref_ptr = cgutils.gep_inbounds(builder, vtable, 0, 0)
item_decref_ptr = cgutils.gep_inbounds(builder, vtable, 0, 1)
dm_item = context.data_model_manager[itemty.instance_type]
if dm_item.contains_nrt_meminfo():
item_incref, item_decref = _get_incref_decref(
context, builder.module, dm_item, "list"
)
builder.store(
builder.bitcast(item_incref, item_incref_ptr.type.pointee),
item_incref_ptr,
)
builder.store(
builder.bitcast(item_decref, item_decref_ptr.type.pointee),
item_decref_ptr,
)
builder.call(setmethod_fn, [dp, vtable])
def make_c_struct(cls, name_types):
"""Construct a Record type from a list of (name:str, type:Types).
The layout of the structure will follow C.
Note: only scalar types are supported currently.
"""
from numba.core.registry import cpu_target
ctx = cpu_target.target_context
offset = 0
fields = []
lltypes = []
for k, ty in name_types:
if not isinstance(ty, (Number, NestedArray)):
msg = "Only Number and NestedArray types are supported, found: {}. "
raise TypeError(msg.format(ty))
if isinstance(ty, NestedArray):
datatype = ctx.data_model_manager[ty].as_storage_type()
else:
datatype = ctx.get_data_type(ty)
lltypes.append(datatype)
size = ctx.get_abi_sizeof(datatype)
align = ctx.get_abi_alignment(datatype)
# align
misaligned = offset % align
if misaligned:
offset += align - misaligned
fields.append((k, {
'type': ty,
'offset': offset,
'alignment': align,
}))
offset += size
# Adjust sizeof structure
abi_size = ctx.get_abi_sizeof(ir.LiteralStructType(lltypes))
return Record(fields, size=abi_size, aligned=True)
def get_struct_type(self, struct):
"""
Get the LLVM struct type for the given Structure class *struct*.
"""
fields = [self.get_value_type(v) for _, v in struct._fields]
return llvmir.LiteralStructType(fields)
