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))