def unituple_constant(context, builder, ty, pyval):
"""
Create a heterogeneous tuple constant.
"""
consts = [context.get_constant_generic(builder, ty.types[i], v)
for i, v in enumerate(pyval)]
return impl_ret_borrowed(
context, builder, ty, cgutils.pack_struct(builder, consts),
)
def core(context, builder, sig, args):
fracty, expty = sig.return_type
float_type = context.get_value_type(fracty)
int_type = context.get_value_type(expty)
fnty = Type.function(float_type, [float_type, Type.pointer(int_type)])
fn = builder.module.get_or_insert_function(fnty, name=nvname)
expptr = cgutils.alloca_once(builder, int_type, name='exp')
ret = builder.call(fn, (args[0], expptr))
return cgutils.pack_struct(builder, (ret, builder.load(expptr)))
def lower_constant_COO(context, builder, typ, pyval):
coords = context.get_constant_generic(builder, typ.coords_type,
pyval.coords)
data = context.get_constant_generic(builder, typ.data_type, pyval.data)
shape = context.get_constant_generic(builder, typ.shape_type, pyval.shape)
fill_value = context.get_constant_generic(builder, typ.fill_value_type,
pyval.fill_value)
return impl_ret_borrowed(
context,
builder,
typ,
cgutils.pack_struct(builder, (data, coords, shape, fill_value)),
)
def core(context, builder, sig, args):
lmod = builder.module
fargtys = []
for arg in prototype_args:
ty = context.get_value_type(arg.ty)
if arg.is_ptr:
ty = ty.as_pointer()
fargtys.append(ty)
fretty = context.get_value_type(retty)
fnty = Type.function(fretty, fargtys)
fn = lmod.get_or_insert_function(fnty, name=func)
# For returned values that are returned through a pointer, we need to
# allocate variables on the stack and pass a pointer to them.
actual_args = []
virtual_args = []
arg_idx = 0
for arg in prototype_args:
if arg.is_ptr:
# Allocate space for return value and add to args
tmp_arg = cgutils.alloca_once(builder,
context.get_value_type(arg.ty))
actual_args.append(tmp_arg)
virtual_args.append(tmp_arg)
else:
actual_args.append(args[arg_idx])
arg_idx += 1
ret = builder.call(fn, actual_args)
# Following the call, we need to assemble the returned values into a
# tuple for returning back to the caller.
tuple_args = []
if retty != types.void:
tuple_args.append(ret)
for arg in virtual_args:
tuple_args.append(builder.load(arg))
if isinstance(nb_retty, types.UniTuple):
return cgutils.pack_array(builder, tuple_args)
else:
return cgutils.pack_struct(builder, tuple_args)
def codegen(context, builder, sig, args):
fnty = ir.FunctionType(
ll_status,
[ll_dict_type, ll_bytes, ll_bytes],
)
[d] = args
[td] = sig.args
fn = builder.module.get_or_insert_function(fnty,
name='numba_dict_popitem')
dm_key = context.data_model_manager[td.key_type]
dm_val = context.data_model_manager[td.value_type]
ptr_key = cgutils.alloca_once(builder, dm_key.get_data_type())
ptr_val = cgutils.alloca_once(builder, dm_val.get_data_type())
dp = _container_get_data(context, builder, td, d)
status = builder.call(
fn,
[
dp,
_as_bytes(builder, ptr_key),
_as_bytes(builder, ptr_val),
],
)
out = context.make_optional_none(builder, keyvalty)
pout = cgutils.alloca_once_value(builder, out)
cond = builder.icmp_signed('==', status, status.type(int(Status.OK)))
with builder.if_then(cond):
key = dm_key.load_from_data_pointer(builder, ptr_key)
val = dm_val.load_from_data_pointer(builder, ptr_val)
keyval = context.make_tuple(builder, keyvalty, [key, val])
optkeyval = context.make_optional_value(builder, keyvalty, keyval)
builder.store(optkeyval, pout)
out = builder.load(pout)
return cgutils.pack_struct(builder, [status, out])
def initialize_dim3(builder, prefix):
x = nvvmutils.call_sreg(builder, "%s.x" % prefix)
y = nvvmutils.call_sreg(builder, "%s.y" % prefix)
z = nvvmutils.call_sreg(builder, "%s.z" % prefix)
return cgutils.pack_struct(builder, (x, y, z))
