def make_constant_array(self, builder, typ, ary):
"""
Create an array structure reifying the given constant array.
A low-level contiguous array constant is created in the LLVM IR.
"""
datatype = self.get_data_type(typ.dtype)
# don't freeze ary of non-contig or bigger than 1MB
size_limit = 10**6
if (self.allow_dynamic_globals and
(typ.layout not in 'FC' or ary.nbytes > size_limit)):
# get pointer from the ary
dataptr = ary.ctypes.data
data = self.add_dynamic_addr(builder, dataptr, info=str(type(dataptr)))
rt_addr = self.add_dynamic_addr(builder, id(ary), info=str(type(ary)))
else:
# Handle data: reify the flattened array in "C" or "F" order as a
# global array of bytes.
flat = ary.flatten(order=typ.layout)
# Note: we use `bytearray(flat.data)` instead of `bytearray(flat)` to
# workaround issue #1850 which is due to numpy issue #3147
consts = cgutils.create_constant_array(llvmir.IntType(8), bytearray(flat.data))
data = cgutils.global_constant(builder, ".const.array.data", consts)
# Ensure correct data alignment (issue #1933)
data.align = self.get_abi_alignment(datatype)
# No reference to parent ndarray
rt_addr = None
# Handle shape
llintp = self.get_value_type(types.intp)
shapevals = [self.get_constant(types.intp, s) for s in ary.shape]
cshape = cgutils.create_constant_array(llintp, shapevals)
# Handle strides
stridevals = [self.get_constant(types.intp, s) for s in ary.strides]
cstrides = cgutils.create_constant_array(llintp, stridevals)
# Create array structure
cary = self.make_array(typ)(self, builder)
intp_itemsize = self.get_constant(types.intp, ary.dtype.itemsize)
self.populate_array(cary,
data=builder.bitcast(data, cary.data.type),
shape=cshape,
strides=cstrides,
itemsize=intp_itemsize,
parent=rt_addr,
meminfo=None)
return cary._getvalue()
def _emit_method_array(self, llvm_module):
"""
Collect exported methods and emit a PyMethodDef array.
:returns: a pointer to the PyMethodDef array.
"""
method_defs = []
for entry in self.export_entries:
name = entry.symbol
llvm_func_name = self._mangle_method_symbol(name)
fnty = self.exported_function_types[entry]
lfunc = ir.Function(llvm_module, fnty, llvm_func_name)
method_name = self.context.insert_const_string(llvm_module, name)
method_def_const = ir.Constant.literal_struct(
(method_name, ir.Constant.bitcast(lfunc, lt._void_star),
METH_VARARGS_AND_KEYWORDS, NULL))
method_defs.append(method_def_const)
sentinel = ir.Constant.literal_struct([NULL, NULL, ZERO, NULL])
method_defs.append(sentinel)
method_array_init = create_constant_array(self.method_def_ty,
method_defs)
method_array = cgutils.add_global_variable(llvm_module,
method_array_init.type,
'.module_methods')
method_array.initializer = method_array_init
method_array.linkage = 'internal'
method_array_ptr = ir.Constant.gep(method_array, [ZERO, ZERO])
return method_array_ptr
def _emit_envgvs_array(self, llvm_module, builder, pyapi):
"""
Emit an array of Environment pointers that needs to be filled at
initialization.
"""
env_setters = []
for entry in self.export_entries:
envgv_name = self.environment_gvs[entry]
gv = self.context.declare_env_global(llvm_module, envgv_name)
envgv = gv.bitcast(lt._void_star)
env_setters.append(envgv)
env_setters_init = create_constant_array(lt._void_star, env_setters)
gv = self.context.insert_unique_const(llvm_module, '.module_envgvs',
env_setters_init)
return gv.gep([ZERO, ZERO])
def _emit_environment_array(self, llvm_module, builder, pyapi):
"""
Emit an array of env_def_t structures (see modulemixin.c)
storing the pickled environment constants for each of the
exported functions.
"""
env_defs = []
for entry in self.export_entries:
env = self.function_environments[entry]
# Constants may be unhashable so avoid trying to cache them
env_def = pyapi.serialize_uncached(env.consts)
env_defs.append(env_def)
env_defs_init = create_constant_array(self.env_def_ty, env_defs)
gv = self.context.insert_unique_const(llvm_module,
'.module_environments',
env_defs_init)
return gv.gep([ZERO, ZERO])
"""
return builder.icmp_unsigned('!=', val, NAT)
def are_not_nat(builder, vals):
"""
Return a predicate which is true if all of *vals* are not NaT.
"""
assert len(vals) >= 1
pred = is_not_nat(builder, vals[0])
for val in vals[1:]:
pred = builder.and_(pred, is_not_nat(builder, val))
return pred
normal_year_months = create_constant_array(
TIMEDELTA64, [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31])
leap_year_months = create_constant_array(
TIMEDELTA64, [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31])
normal_year_months_acc = create_constant_array(
TIMEDELTA64, [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334])
leap_year_months_acc = create_constant_array(
TIMEDELTA64, [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335])
@lower_constant(types.NPDatetime)
@lower_constant(types.NPTimedelta)
def datetime_constant(context, builder, ty, pyval):
return DATETIME64(pyval.astype(np.int64))
# Arithmetic operators on timedelta64