Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
start = timeit.default_timer()
with pnlvm.LLVMBuilderContext() as ctx:
double_ptr_ty = ctx.float_ty.as_pointer()
func_ty = ir.FunctionType(ir.VoidType(), (double_ptr_ty, double_ptr_ty, double_ptr_ty))
# get builtin IR
builtin = ctx.get_llvm_function('__pnl_builtin_vxm')
# Create square vector matrix multiply
function = ir.Function(ctx.module, func_ty, name="vxsqm")
_x = ctx.int32_ty(x)
_y = ctx.int32_ty(y)
_v, _m, _o = function.args
block = function.append_basic_block(name="entry")
builder = ir.IRBuilder(block)
builder.call(builtin, [_v, _m, _x, _y, _o])
builder.ret_void()
# This triggers recompile if needed so it should be included in the measurement
binf2 = pnlvm.LLVMBinaryFunction.get('vxsqm')
stop = timeit.default_timer()
print("Build time elapsed {:f}".format(stop-start))
start = timeit.default_timer()
for _ in range(ITERATIONS):
binf2(ct_vec, ct_mat, ct_res)
stop = timeit.default_timer()
print("LLVM-custom time elapsed {:f}".format(stop-start))
# Use all close to ignore rounding errors
if not np.allclose(llvm_res, result):
def test_as_arg(self):
"""
- Is as_arg() and from_arg() implemented?
- Are they the inverse of each other?
"""
fnty = ir.FunctionType(ir.VoidType(), [])
function = ir.Function(self.module, fnty, name="test_as_arg")
builder = ir.IRBuilder()
builder.position_at_end(function.append_basic_block())
undef_value = ir.Constant(self.datamodel.get_value_type(), None)
args = self.datamodel.as_argument(builder, undef_value)
self.assertIsNot(args, NotImplemented, "as_argument returned "
"NotImplementedError")
if isinstance(args, (tuple, list)):
def recur_tuplize(args, func=None):
for arg in args:
if isinstance(arg, (tuple, list)):
yield tuple(recur_tuplize(arg, func=func))
else:
if func is None:
yield arg
else:
def bf_to_ir(bf):
ast = parse(bf)
byte = ir.IntType(8)
int32 = ir.IntType(32)
size_t = ir.IntType(64)
void = ir.VoidType()
module = ir.Module(name=__file__)
main_type = ir.FunctionType(int32, ())
main_func = ir.Function(module, main_type, name="main")
entry = main_func.append_basic_block(name="entry")
builder = ir.IRBuilder(entry)
putchar_type = ir.FunctionType(int32, (int32,))
putchar = ir.Function(module, putchar_type, name="putchar")
getchar_type = ir.FunctionType(int32, ())
getchar = ir.Function(module, getchar_type, name="getchar")
bzero_type = ir.FunctionType(void, (byte.as_pointer(), size_t))
bzero = ir.Function(module, bzero_type, name="bzero")
index_type = ir.IntType(INDEX_BIT_SIZE)
index = builder.alloca(index_type)
builder.store(ir.Constant(index_type, 0), index)
tape_type = byte
tape = builder.alloca(tape_type, size=2 ** INDEX_BIT_SIZE)
def dynamic_array_set(self, dyn_array_ptr, array_type):
# START
dyn_array_set_type = ir.FunctionType(type_map[VOID], [dyn_array_ptr, type_map[INT], array_type])
dyn_array_set = ir.Function(self.module, dyn_array_set_type, '{}.array.set'.format(str(array_type)))
dyn_array_set.args[0].name = 'self'
dyn_array_set_entry = dyn_array_set.append_basic_block('entry')
builder = ir.IRBuilder(dyn_array_set_entry)
self.builder = builder
dyn_array_set_exit = dyn_array_set.append_basic_block('exit')
dyn_array_set_index_out_of_bounds = dyn_array_set.append_basic_block('index_out_of_bounds')
dyn_array_set_is_index_less_than_zero = dyn_array_set.append_basic_block('is_index_less_than_zero')
dyn_array_set_negative_index = dyn_array_set.append_basic_block('negative_index')
dyn_array_set_block = dyn_array_set.append_basic_block('set')
builder.position_at_end(dyn_array_set_entry)
array_ptr = builder.alloca(dyn_array_ptr)
builder.store(dyn_array_set.args[0], array_ptr)
index_ptr = builder.alloca(type_map[INT])
builder.store(dyn_array_set.args[1], index_ptr)
value_ptr = builder.alloca(array_type)
builder.store(dyn_array_set.args[2], value_ptr)
# BODY
index_val = builder.load(index_ptr)
'''
# assume that the function returns a real. Note that this is verified by
# looking at the type of the head of the converted expression.
ret_type = real_type if self._known_ret_type is None else self._known_ret_type
# create an empty module
module = ir.Module(name=__file__)
func_type = ir.FunctionType(ret_type, tuple(arg.type for arg in self.args))
# declare a function inside the module
func = ir.Function(module, func_type, name=self.func_name)
# implement the function
block = func.append_basic_block(name='entry')
self.builder = ir.IRBuilder(block)
self.lookup_args = {arg.name: func_arg for arg, func_arg in zip(self.args, func.args)}
ir_code = self._gen_ir(self.expr)
# if the return type isn't correct then try again
if self._known_ret_type is None:
# determine the type returned
if ir_code.type == void_type:
if self._returned_type is not None:
# we returned something so use that type
self._known_ret_type = self._returned_type
# force generation again in case multiple returns of different types
return self.generate_ir()
else:
# actually returned void e.g. Print[]
def dynamic_array_get(self, dyn_array_ptr, array_type):
# START
dyn_array_get_type = ir.FunctionType(array_type, [dyn_array_ptr, type_map[INT]])
dyn_array_get = ir.Function(self.module, dyn_array_get_type, '{}.array.get'.format(str(array_type)))
dyn_array_get.args[0].name = 'self'
dyn_array_get_entry = dyn_array_get.append_basic_block('entry')
builder = ir.IRBuilder(dyn_array_get_entry)
self.builder = builder
dyn_array_get_exit = dyn_array_get.append_basic_block('exit')
dyn_array_get_index_out_of_bounds = dyn_array_get.append_basic_block('index_out_of_bounds')
dyn_array_get_is_index_less_than_zero = dyn_array_get.append_basic_block('is_index_less_than_zero')
dyn_array_get_negative_index = dyn_array_get.append_basic_block('negative_index')
dyn_array_get_block = dyn_array_get.append_basic_block('get')
builder.position_at_end(dyn_array_get_entry)
array_ptr = builder.alloca(dyn_array_ptr)
builder.store(dyn_array_get.args[0], array_ptr)
index_ptr = builder.alloca(type_map[INT])
builder.store(dyn_array_get.args[1], index_ptr)
# BODY
index_val = builder.load(index_ptr)
size_ptr = builder.gep(builder.load(array_ptr), [zero_32, zero_32], inbounds=True)
size_val = builder.load(size_ptr)
def _define_nrt_decref(module, atomic_decr):
"""
Implement NRT_decref in the module
"""
fn_decref = module.get_or_insert_function(incref_decref_ty,
name="NRT_decref")
# Cannot inline this for refcount pruning to work
fn_decref.attributes.add('noinline')
calldtor = module.add_function(ir.FunctionType(ir.VoidType(), [_pointer_type]),
name="NRT_MemInfo_call_dtor")
builder = ir.IRBuilder(fn_decref.append_basic_block())
[ptr] = fn_decref.args
is_null = builder.icmp_unsigned("==", ptr, cgutils.get_null_value(ptr.type))
with cgutils.if_unlikely(builder, is_null):
builder.ret_void()
if _debug_print:
cgutils.printf(builder, "*** NRT_Decref %zu [%p]\n", builder.load(ptr),
ptr)
if binding.get_process_triple().startswith("powerpc"):
builder.fence("release")
newrefct = builder.call(atomic_decr,
[builder.bitcast(ptr, atomic_decr.args[0].type)])
refct_eq_0 = builder.icmp_unsigned("==", newrefct,
ir.Constant(newrefct.type, 0))
with cgutils.if_unlikely(builder, refct_eq_0):
def _define_nrt_unresolved_abort(ctx, module):
"""
Defines an abort function due to unresolved symbol.
The function takes no args and will always raise an exception.
It should be safe to call this function with incorrect number of arguments.
"""
fnty = ctx.call_conv.get_function_type(types.none, ())
fn = ir.Function(module, fnty, name="nrt_unresolved_abort")
bb = fn.append_basic_block()
builder = ir.IRBuilder(bb)
msg = "numba jitted function aborted due to unresolved symbol"
ctx.call_conv.return_user_exc(builder, RuntimeError, (msg,))
return fn
FCMP_ONE: '!=',
FCMP_ORD: 'ord',
}
_fcmp_umap = {
FCMP_UEQ: '==',
FCMP_UGT: '>',
FCMP_UGE: '>=',
FCMP_ULT: '<',
FCMP_ULE: '<=',
FCMP_UNE: '!=',
FCMP_UNO: 'uno',
}
class Builder(ir.IRBuilder):
def icmp(self, pred, lhs, rhs, name=''):
if pred in _icmp_umap:
return self.icmp_unsigned(_icmp_umap[pred], lhs, rhs, name=name)
else:
return self.icmp_signed(_icmp_smap[pred], lhs, rhs, name=name)
def fcmp(self, pred, lhs, rhs, name=''):
if pred in _fcmp_umap:
return self.fcmp_unordered(_fcmp_umap[pred], lhs, rhs, name=name)
else:
return self.fcmp_ordered(_fcmp_omap[pred], lhs, rhs, name=name)
class MetaDataString(ir.MetaDataString):
@staticmethod