def _setup_mt_rand_init(ctx, state_ty, init_scalar):
seed_ty = state_ty.elements[0].element
builder = _setup_builtin_func_builder(ctx, "mt_rand_init",
(state_ty.as_pointer(), seed_ty))
state, seed = builder.function.args
default_seed = seed.type(19650218)
builder.call(init_scalar, [state, default_seed])
# python considers everything to be an array
key_array = builder.alloca(ir.ArrayType(seed.type, 1))
key_p = builder.gep(key_array, [ctx.int32_ty(0), ctx.int32_ty(0)])
builder.store(seed, key_p)
pi = builder.alloca(ctx.int32_ty)
builder.store(ctx.int32_ty(1), pi)
pj = builder.alloca(ctx.int32_ty)
builder.store(ctx.int32_ty(0), pj)
array = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(0)])
a_0 = builder.gep(array, [ctx.int32_ty(0), ctx.int32_ty(0)])
# This loop should go from max(N, len(key)) -> 0,
# but we know the key length so we can hardcode it
with helpers.for_loop_zero_inc(builder, ctx.int32_ty(_MERSENNE_N),
"add_key") as (b, _):
i = builder.load(pi)
i_m1 = b.sub(i, ctx.int32_ty(1))
pa_i = b.gep(array, [ctx.int32_ty(0), i])
pa_i_m1 = b.gep(array, [ctx.int32_ty(0), i_m1])
# Load key element
j = b.load(pj)
pkey = b.gep(key_array, [ctx.int32_ty(0), j])
# Update key index
j_new = b.add(j, ctx.int32_ty(1))
j_ovf = b.icmp_unsigned(">=", j_new, ctx.int32_ty(1))
j_new = b.select(j_ovf, ctx.int32_ty(0), j_new)
b.store(j_new, pj)
# Mix in the key
val = b.load(pa_i_m1)
val = b.xor(val, b.lshr(val, val.type(30)))
val = b.mul(val, val.type(1664525))
val = b.xor(b.load(pa_i), val)
val = b.add(val, b.load(pkey))
val = b.add(val, b.zext(j, val.type))
val = b.and_(val, val.type(0xffffffff))
b.store(val, pa_i)
# Update the index
i = b.add(i, ctx.int32_ty(1))
b.store(i, pi)
i_ovf = b.icmp_unsigned(">=", i, ctx.int32_ty(_MERSENNE_N))
with b.if_then(i_ovf, likely=False):
b.store(ctx.int32_ty(1), pi)
b.store(val, a_0)
with helpers.for_loop_zero_inc(builder, ctx.int32_ty(_MERSENNE_N - 1),
"second_shuffle") as (b, _):
i = builder.load(pi)
i_m1 = b.sub(i, ctx.int32_ty(1))
pa_i = b.gep(array, [ctx.int32_ty(0), i])
pa_i_m1 = b.gep(array, [ctx.int32_ty(0), i_m1])
val = b.load(pa_i_m1)
val = b.xor(val, b.lshr(val, val.type(30)))
val = b.mul(val, val.type(1566083941))
val = b.xor(b.load(pa_i), val)
val = b.sub(val, b.zext(i, val.type))
val = b.and_(val, val.type(0xffffffff))
b.store(val, pa_i)
# Update the index
i = b.add(i, ctx.int32_ty(1))
b.store(i, pi)
i_ovf = b.icmp_unsigned(">=", i, ctx.int32_ty(_MERSENNE_N))
with b.if_then(i_ovf, likely=False):
b.store(ctx.int32_ty(1), pi)
b.store(val, a_0)
# set the 0th element to INT_MIN
builder.store(a_0.type.pointee(0x80000000), a_0)
builder.ret_void()
return builder.function
def __init__(self, dmm, fe_type):
super(EphemeralArrayModel, self).__init__(dmm, fe_type)
self._data_type = ir.ArrayType(self._pointee_be_type,
self._fe_type.count)
def __init__(self, dmm, fe_type):
super(RecordModel, self).__init__(dmm, fe_type)
self._models = [self._dmm.lookup(t) for _, t in fe_type.members]
self._be_type = ir.ArrayType(ir.IntType(8), fe_type.size)
self._be_ptr_type = self._be_type.as_pointer()
def _setup_mt_rand_init(ctx, state_ty, init_scalar):
seed_ty = state_ty.elements[0].element
init_ty = ir.FunctionType(ir.VoidType(), (state_ty.as_pointer(), seed_ty))
# Create init_array function
init = ir.Function(ctx.module, init_ty, name="__pnl_builtin_mt_rand_init")
init.attributes.add('argmemonly')
init.attributes.add('alwaysinline')
block = init.append_basic_block(name="entry")
builder = ir.IRBuilder(block)
builder.debug_metadata = LLVMBuilderContext.get_debug_location(init, None)
state, seed = init.args
# Add function arg attributes
state.attributes.add('nonnull')
state.attributes.add('noalias')
default_seed = seed.type(19650218)
builder.call(init_scalar, [state, default_seed])
# python considers everything to be an array
key_array = builder.alloca(ir.ArrayType(seed.type, 1))
key_p = builder.gep(key_array, [ctx.int32_ty(0), ctx.int32_ty(0)])
builder.store(seed, key_p)
pi = builder.alloca(ctx.int32_ty)
builder.store(ctx.int32_ty(1), pi)
pj = builder.alloca(ctx.int32_ty)
builder.store(ctx.int32_ty(0), pj)
array = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(0)])
a_0 = builder.gep(array, [ctx.int32_ty(0), ctx.int32_ty(0)])
# This loop should go from max(N, len(key)) -> 0,
# but we know the key length so we can hardcode it
with helpers.for_loop_zero_inc(builder,
ctx.int32_ty(_MERSENNE_N),
"add_key") as (b, _):
i = builder.load(pi)
i_m1 = b.sub(i, ctx.int32_ty(1))
pa_i = b.gep(array, [ctx.int32_ty(0), i])
pa_i_m1 = b.gep(array, [ctx.int32_ty(0), i_m1])
# Load key element
j = b.load(pj)
pkey = b.gep(key_array, [ctx.int32_ty(0), j])
# Update key index
j_new = b.add(j, ctx.int32_ty(1))
j_ovf = b.icmp_unsigned(">=", j_new, ctx.int32_ty(1))
j_new = b.select(j_ovf, ctx.int32_ty(0), j_new)
b.store(j_new, pj)
# Mix in the key
val = b.load(pa_i_m1)
val = b.xor(val, b.lshr(val, val.type(30)))
val = b.mul(val, val.type(1664525))
val = b.xor(b.load(pa_i), val)
val = b.add(val, b.load(pkey))
val = b.add(val, b.zext(j, val.type))
val = b.and_(val, val.type(0xffffffff))
b.store(val, pa_i)
# Update the index
i = b.add(i, ctx.int32_ty(1))
b.store(i, pi)
i_ovf = b.icmp_unsigned(">=", i, ctx.int32_ty(_MERSENNE_N))
with b.if_then(i_ovf, likely=False):
b.store(ctx.int32_ty(1), pi)
b.store(val, a_0)
with helpers.for_loop_zero_inc(builder,
ctx.int32_ty(_MERSENNE_N - 1),
"second_shuffle") as (b, _):
i = builder.load(pi)
i_m1 = b.sub(i, ctx.int32_ty(1))
pa_i = b.gep(array, [ctx.int32_ty(0), i])
pa_i_m1 = b.gep(array, [ctx.int32_ty(0), i_m1])
val = b.load(pa_i_m1)
val = b.xor(val, b.lshr(val, val.type(30)))
val = b.mul(val, val.type(1566083941))
val = b.xor(b.load(pa_i), val)
val = b.sub(val, b.zext(i, val.type))
val = b.and_(val, val.type(0xffffffff))
b.store(val, pa_i)
# Update the index
i = b.add(i, ctx.int32_ty(1))
b.store(i, pi)
i_ovf = b.icmp_unsigned(">=", i, ctx.int32_ty(_MERSENNE_N))
with b.if_then(i_ovf, likely=False):
b.store(ctx.int32_ty(1), pi)
b.store(val, a_0)
# set the 0th element to INT_MIN
builder.store(a_0.type.pointee(0x80000000), a_0)
builder.ret_void()
return init
def get_mersenne_twister_state_struct(ctx):
return ir.LiteralStructType([
ir.ArrayType(ctx.int32_ty, _MERSENNE_N), # array
ctx.int32_ty, #index
ctx.int32_ty, #last_gauss available
ctx.float_ty]) #last_gauss
def type(element_type: ir.Type, count: int) -> ir.Type:
return ir.ArrayType(element_type, count)
def array(typ, val):
return ir.Constant(ir.ArrayType(typ, len(val)), val)
int B[1024];
A[50] = A[49] + 5;
B[0] = B[1] + 10;
return 0;
}
'''
# Cria o módulo.
module = ir.Module('meu_modulo.bc')
# Array global de 1024 elementos.
typeA = ir.ArrayType(ir.IntType(64), 1024)
arrayA = ir.GlobalVariable(module, typeA, "A")
arrayA.initializer = ir.Constant.array(ir.IntType(64), 0)
# arrayA.initializer = ir.IntType(64)
arrayA.linkage = "common"
# arrayA.initializer = ir.Constant(ir.IntType(64), 0)
arrayA.align = 16
# Cria um valor zero para colocar no retorno.
Zero64 = ir.Constant(ir.IntType(64), 0)
# Declara o tipo do retorno da função main.
mainFnReturnType = ir.IntType(64)
# Cria a função main.
def _codegen_String(node):
return ir.Constant(
ir.ArrayType(ir.IntType(4), len(str(node.value))),
[ord(char) for char in node.value],
)
def print_string(self, string):
stringz = self.stringz(string)
str_ptr = self.alloc_and_store(stringz, ir.ArrayType(stringz.type.element, stringz.type.count))
str_ptr = self.gep(str_ptr, [self.const(0), self.const(0)])
str_ptr = self.builder.bitcast(str_ptr, type_map[INT].as_pointer())
self.call('puts', [str_ptr])
def stringz(string):
n = len(string) + 1
buf = bytearray((' ' * n).encode('ascii'))
buf[-1] = 0
buf[:-1] = string.encode('utf-8')
return ir.Constant(ir.ArrayType(type_map[INT8], n), buf)
def type(element_type, count):
return ir.ArrayType(element_type, count)
def gen_code(tree, symbol_table, sema_success):
# symbol = {
# "symbol_type": None,
# "name": None,
# "value_type": None,
# "scope": None,
# "parameters": [],
# "dimensions": [],
# "declared": True,
# "inicialized": False,
# "used": False
# }
global module
global info
# Define Global Variables and Functions
for symbol in symbol_table:
if (symbol["symbol_type"] == "variable"
and symbol["scope"] == "global"):
var_type = symbol["value_type"]
if (var_type == "inteiro"):
if (len(symbol["dimensions"]) == 0):
g = ir.GlobalVariable(module, ir.IntType(32),
symbol["name"])
if (len(symbol["dimensions"]) == 1):
g_type = ir.ArrayType(ir.IntType(32),
int(symbol["dimensions"][0]))
g = ir.GlobalVariable(module, g_type, symbol["name"])
info["global_variables"].append(g)
elif (var_type == "flutuante"):
if (len(symbol["dimensions"]) == 0):
g = ir.GlobalVariable(module, ir.FloatType(),
symbol["name"])
if (len(symbol["dimensions"]) == 1):
g_type = ir.ArrayType(ir.FloatType(),
int(symbol["dimensions"][0]))
g = ir.GlobalVariable(module, g_type, symbol["name"])
g.linkage = "common"
g.align = 4
info["global_variables"].append(g)
elif (symbol["symbol_type"] == "function"):
if (symbol["name"] == "principal"):
symbol["name"] = "main"
arguments_list = []
if (len(symbol["parameters"]) > 0):
for a in symbol["parameters"]:
if (a["par_type"] == "inteiro"):
arguments_list.append(ir.IntType(32))
else:
arguments_list.append(ir.FloatType())
if (len(symbol["return"]) > 0):
if (symbol["return"][0]["ret_type"] == "inteiro"):
f_ret = ir.IntType(32)
else:
f_ret = ir.FloatType()
f_func = ir.FunctionType(f_ret, arguments_list)
f = ir.Function(module, f_func, name=symbol["name"])
entryBlock = f.append_basic_block('entry')
builder = ir.IRBuilder(entryBlock)
else:
f_func = ir.FunctionType(ir.VoidType(), arguments_list)
f = ir.Function(module, f_func, name=symbol["name"])
entryBlock = f.append_basic_block('entry')
builder = ir.IRBuilder(entryBlock)
for i in range(len(f.args)):
f.args[i].name = symbol["parameters"][i]["par_name"]
functions.append({
"function": f,
"builder": builder,
"arguments": f.args
})
go_through_tree(tree, functions)
file = open('module.ll', 'w')
file.write(str(module))
file.close()
print(module)
def _setup_mt_rand_integer(ctx, state_ty):
int64_ty = ir.IntType(64)
# Generate random number generator function.
# It produces random 32bit numberin a 64bit word
builder = _setup_builtin_func_builder(
ctx, "mt_rand_int32", (state_ty.as_pointer(), int64_ty.as_pointer()))
state, out = builder.function.args
array = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(0)])
pidx = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(1)])
idx = builder.load(pidx)
cond = builder.icmp_signed(">=", idx, ctx.int32_ty(_MERSENNE_N))
with builder.if_then(cond, likely=False):
mag01 = ir.ArrayType(array.type.pointee.element, 2)([0, 0x9908b0df])
pmag01 = builder.alloca(mag01.type)
builder.store(mag01, pmag01)
with helpers.for_loop_zero_inc(builder,
ctx.int32_ty(_MERSENNE_N - _MERSENNE_M),
"first_half") as (b, kk):
pkk = b.gep(array, [ctx.int32_ty(0), kk])
pkk_1 = b.gep(array, [ctx.int32_ty(0), b.add(kk, ctx.int32_ty(1))])
val_kk = b.and_(b.load(pkk), pkk.type.pointee(0x80000000))
val_kk_1 = b.and_(b.load(pkk_1), pkk_1.type.pointee(0x7fffffff))
val = b.or_(val_kk, val_kk_1)
val_1 = b.and_(val, val.type(1))
pval_mag = b.gep(pmag01, [ctx.int32_ty(0), val_1])
val_mag = b.load(pval_mag)
val_shift = b.lshr(val, val.type(1))
kk_m = b.add(kk, ctx.int32_ty(_MERSENNE_M))
pval_kk_m = b.gep(array, [ctx.int32_ty(0), kk_m])
val_kk_m = b.load(pval_kk_m)
val = b.xor(val_kk_m, val_shift)
val = b.xor(val, val_mag)
b.store(val, pkk)
with helpers.for_loop(builder, ctx.int32_ty(_MERSENNE_N - _MERSENNE_M),
ctx.int32_ty(_MERSENNE_N), ctx.int32_ty(1),
"second_half") as (b, kk):
pkk = b.gep(array, [ctx.int32_ty(0), kk])
is_last = b.icmp_unsigned("==", kk, ctx.int32_ty(_MERSENNE_N - 1))
idx_1 = b.select(is_last, ctx.int32_ty(0),
b.add(kk, ctx.int32_ty(1)))
pkk_1 = b.gep(array, [ctx.int32_ty(0), idx_1])
val_kk = b.and_(b.load(pkk), pkk.type.pointee(0x80000000))
val_kk_1 = b.and_(b.load(pkk_1), pkk.type.pointee(0x7fffffff))
val = b.or_(val_kk, val_kk_1)
val_1 = b.and_(val, val.type(1))
pval_mag = b.gep(pmag01, [ctx.int32_ty(0), val_1])
val_mag = b.load(pval_mag)
val_shift = b.lshr(val, val.type(1))
kk_m = b.add(kk, ctx.int32_ty(_MERSENNE_M - _MERSENNE_N))
pval_kk_m = b.gep(array, [ctx.int32_ty(0), kk_m])
val_kk_m = b.load(pval_kk_m)
val = b.xor(val_kk_m, val_shift)
val = b.xor(val, val_mag)
b.store(val, pkk)
builder.store(pidx.type.pointee(0), pidx)
# Get pointer and update index
idx = builder.load(pidx)
pval = builder.gep(array, [ctx.int32_ty(0), idx])
idx = builder.add(idx, idx.type(1))
builder.store(idx, pidx)
# Load and temper
val = builder.load(pval)
tmp = builder.lshr(val, val.type(11))
val = builder.xor(val, tmp)
tmp = builder.shl(val, val.type(7))
tmp = builder.and_(tmp, tmp.type(0x9d2c5680))
val = builder.xor(val, tmp)
tmp = builder.shl(val, val.type(15))
tmp = builder.and_(tmp, tmp.type(0xefc60000))
val = builder.xor(val, tmp)
tmp = builder.lshr(val, val.type(18))
val = builder.xor(val, tmp)
# val is now random 32bit integer
val = builder.zext(val, out.type.pointee)
builder.store(val, out)
builder.ret_void()
return builder.function
def __init__(self, dmm, fe_type):
super(CharSeq, self).__init__(dmm, fe_type)
charty = ir.IntType(8)
self._be_type = ir.ArrayType(charty, fe_type.count)
def arrayOpera(ast, builder, symblos):
i32_0 = ir.Constant(i32, 0)
if ast[c.op] == "+":
if ast[c.var] in symblos:
value_op = builder.load(symblos[ast[c.var]])
if '#array' in symblos:
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.add(array_i_value,
valor_somado,
name="add")
builder.store(new_value_index, array_poiter)
else:
array_example = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
#print(array_example)
array_type = ir.ArrayType(
i32, len(array_example)
) #According to documentation, the second argument has to be an Python Integer. It can't be ir.Constant(i32, 3) for example.
arr = ir.Constant(array_type, array_example)
ptr = builder.alloca(array_type) #allocate memory
builder.store(arr, ptr)
symblos['#array'] = ptr
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.add(array_i_value,
valor_somado,
name="add")
builder.store(new_value_index, array_poiter)
else:
value_op = ir.Constant(i32, ast['var'])
#builder.store(ast[c.var], value_op)
if '#array' in symblos:
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.add(array_i_value,
valor_somado,
name="add")
builder.store(new_value_index, array_poiter)
else:
array_example = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
#print(array_example)
array_type = ir.ArrayType(
i32, len(array_example)
) #According to documentation, the second argument has to be an Python Integer. It can't be ir.Constant(i32, 3) for example.
arr = ir.Constant(array_type, array_example)
ptr = builder.alloca(array_type) #allocate memory
builder.store(arr, ptr)
symblos['#array'] = ptr
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.add(array_i_value,
valor_somado,
name="add")
builder.store(new_value_index, array_poiter)
else:
if ast[c.var] in symblos:
value_op = builder.load(symblos[ast[c.var]])
if '#array' in symblos:
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.sub(array_i_value,
valor_somado,
name="sub")
builder.store(new_value_index, array_poiter)
else:
array_example = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
#print(array_example)
array_type = ir.ArrayType(
i32, len(array_example)
) #According to documentation, the second argument has to be an Python Integer. It can't be ir.Constant(i32, 3) for example.
arr = ir.Constant(array_type, array_example)
ptr = builder.alloca(array_type) #allocate memory
builder.store(arr, ptr)
symblos['#array'] = ptr
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.sub(array_i_value,
valor_somado,
name="sub")
builder.store(new_value_index, array_poiter)
else:
value_op = ir.Constant(i32, ast[c.var])
if '#array' in symblos:
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.sub(array_i_value,
valor_somado,
name="sub")
builder.store(new_value_index, array_poiter)
else:
array_example = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
#print(array_example)
array_type = ir.ArrayType(
i32, len(array_example)
) #According to documentation, the second argument has to be an Python Integer. It can't be ir.Constant(i32, 3) for example.
arr = ir.Constant(array_type, array_example)
ptr = builder.alloca(array_type) #allocate memory
builder.store(arr, ptr)
symblos['#array'] = ptr
array_poiter = builder.gep(symblos['#array'],
[i32_0, value_op])
array_i_value = builder.load(array_poiter)
valor_somado = ir.Constant(i32, ast[c.value])
new_value_index = builder.sub(array_i_value,
valor_somado,
name="sub")
builder.store(new_value_index, array_poiter)
def random_init():
"""
Initialize the random states with system entropy.
"""
global _pid
if _pid != os.getpid():
b = os.urandom(N * 4)
for n in ('py_random_state', 'np_random_state'):
_helperlib.rnd_seed(_helperlib.c_helpers[n], b)
_pid = os.getpid()
# This is the same struct as rnd_state_t in _helperlib.c.
rnd_state_t = ir.LiteralStructType(
[int32_t, ir.ArrayType(int32_t, N), int32_t, double])
rnd_state_ptr_t = ir.PointerType(rnd_state_t)
# Accessors
def get_index_ptr(builder, state_ptr):
return cgutils.gep_inbounds(builder, state_ptr, 0, 0)
def get_array_ptr(builder, state_ptr):
return cgutils.gep_inbounds(builder, state_ptr, 0, 1)
def get_has_gauss_ptr(builder, state_ptr):
return cgutils.gep_inbounds(builder, state_ptr, 0, 2)
def array(ast, builder, symbols):
if ast[c.array][c.value] == None:
symbol_table = {}
if '#array' in symbols:
symbol_table['vetor'] = symbols['#array']
else:
array_example = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
#print(array_example)
array_type = ir.ArrayType(
i32, len(array_example)
) #According to documentation, the second argument has to be an Python Integer. It can't be ir.Constant(i32, 3) for example.
arr = ir.Constant(array_type, array_example)
ptr = builder.alloca(array_type) #allocate memory
builder.store(arr, ptr)
symbols['#array'] = ptr
symbol_table['vetor'] = ptr
i32_100 = ir.Constant(i32, 100)
i32_0 = ir.Constant(i32, 0)
i32_1 = ir.Constant(i32, 1)
array_prime = [
2, 3, 5, 7, 11, 13, 17, 19, 23, 31, 37, 41, 43, 47, 53, 59, 61, 67,
71, 73, 79, 83, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139,
149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367,
373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443,
449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523,
523, 541, 547
]
array_type = ir.ArrayType(i32, 100)
arr = ir.Constant(array_type, array_prime)
ptr = builder.alloca(array_type)
builder.store(arr, ptr)
symbol_table["#array_prime"] = ptr
value_array = builder.alloca(i32)
builder.store(i32_1, value_array)
symbol_table["value_array"] = value_array
for_body_block = builder.append_basic_block("for_body_externo")
for_after_block = builder.append_basic_block("for_after_externo")
for_body_block_interno = builder.append_basic_block("for_body")
for_after_block_interno = builder.append_basic_block("for_after")
#iniciando o for(int i = 0; ...)
i_ptr = builder.alloca(i32)
i_value = ir.Constant(i32, 0)
builder.store(i_value, i_ptr)
symbol_table["i"] = i_ptr
#Fazendo i< 28; Quando i =0
current_i_value = builder.load(symbol_table["i"])
cond_head = builder.icmp_signed('<',
current_i_value,
i32_100,
name="lt")
builder.cbranch(cond_head, for_body_block, for_after_block)
builder.position_at_start(for_body_block)
current_i_value = builder.load(symbol_table["i"])
array_i_ponter = builder.gep(symbol_table["vetor"],
[i32_0, current_i_value])
max_j_value = builder.load(array_i_ponter)
#operação do for
# Aqui dentro tem q fazer o segundo for
#iniciando o for(int i = 0; ...)
j_ptr = builder.alloca(i32)
j_value = ir.Constant(i32, 0)
builder.store(j_value, j_ptr)
symbol_table["j"] = j_ptr
#Fazendo i< 28; Quando i =0
current_j_value = builder.load(symbol_table["j"])
cond_head_interno = builder.icmp_signed('<',
current_j_value,
max_j_value,
name="lt")
builder.cbranch(cond_head_interno, for_body_block_interno,
for_after_block_interno)
builder.position_at_start(for_body_block_interno)
value_atual = builder.load(symbol_table["value_array"])
value_primo_pointer = builder.gep(symbol_table["#array_prime"],
[i32_0, current_i_value])
value_primo_prod = builder.load(value_primo_pointer)
value_prod = builder.mul(value_atual, value_primo_prod, name="mul")
builder.store(value_prod, symbol_table["value_array"])
#Fim do for interno
current_j_value = builder.load(symbol_table["j"])
new_j_value = builder.add(current_j_value, i32_1, name="add")
builder.store(new_j_value, symbol_table["j"])
cond_body_interno = builder.icmp_signed('<',
new_j_value,
max_j_value,
name="lt")
builder.cbranch(cond_body_interno, for_body_block_interno,
for_after_block_interno)
builder.position_at_start(for_after_block_interno)
# Inicio da incremento no valor de i, for_externo
new_i_value = builder.add(current_i_value, i32_1, name="add")
builder.store(new_i_value, symbol_table["i"])
cond_body = builder.icmp_signed('<', new_i_value, i32_100, name="lt")
builder.cbranch(cond_body, for_body_block, for_after_block)
builder.position_at_start(for_after_block)
#Load do valor final e atribuição a variavel q chamou ele
var_recebe = symbols[ast[c.var]]
value_stored = builder.load(symbol_table["value_array"])
builder.store(value_stored, var_recebe)
elif ast[c.array][c.value] in symbols:
var_name = symbols[ast[c.array][c.value]]
if '#array' in symbols:
ptr = symbols['#array']
int_0 = ir.Constant(i32, 0)
value = builder.load(var_name)
# index out of range criar
address = builder.gep(ptr, [int_0, value])
valor_stored = builder.load(address)
var_recebe = symbols[ast[c.var]]
builder.store(valor_stored, var_recebe)
else:
array_example = array_example = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
#print(array_example)
array_type = ir.ArrayType(
i32, len(array_example)
) #According to documentation, the second argument has to be an Python Integer. It can't be ir.Constant(i32, 3) for example.
arr = ir.Constant(array_type, array_example)
ptr = builder.alloca(array_type) #allocate memory
builder.store(arr, ptr)
symbols['#array'] = ptr
#print(symbols)
int_0 = ir.Constant(i32, 0)
value = builder.load(var_name)
# index out of range criar
address = builder.gep(ptr, [int_0, value])
valor_stored = builder.load(address)
var_recebe = symbols[ast[c.var]]
builder.store(valor_stored, var_recebe)
else:
value_int = ast[c.array][c.value]
# index out of range criar
if '#array' in symbols:
ptr = symbols['#array']
int_0 = ir.Constant(i32, 0)
value = ir.Constant(i32, value_int)
address = builder.gep(ptr, [int_0, value])
var_name = symbols[ast[c.var]]
valor_stored = builder.load(address)
builder.store(valor_stored, var_name)
else:
array_example = [
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
]
#array_example = [3,5,8]
array_type = ir.ArrayType(
i32, len(array_example)
) #According to documentation, the second argument has to be an Python Integer. It can't be ir.Constant(i32, 3) for example.
arr = ir.Constant(array_type, array_example)
ptr = builder.alloca(array_type) #allocate memory
builder.store(arr, ptr)
symbols['#array'] = ptr
int_0 = ir.Constant(i32, 0)
value = value = ir.Constant(i32, value_int)
address = builder.gep(ptr, [int_0, value])
valor_stored = builder.load(address)
var_name = symbols[ast[c.var]]
builder.store(valor_stored, var_name)
def stringz(string):
n = (len(string) + 1)
buf = bytearray((' ' * n).encode('ascii'))
buf[-1] = 0
buf[:-1] = string.encode('utf-8')
return ir.Constant(ir.ArrayType(ir.IntType(8), n), buf)
def make_bytearray(buf):
b = bytearray(buf)
n = len(b)
return ir.Constant(ir.ArrayType(char_ty, n), b)
def array(element, count):
return ir.ArrayType(element, count)
def get_data_type(self):
return ir.ArrayType(self._pointee_be_type, self._fe_type.count)
def _setup_mt_rand_integer(ctx, state_ty):
int64_ty = ir.IntType(64)
# Generate random number generator function. It produces random 32bit numberin a 64bit word
gen_ty = ir.FunctionType(ir.VoidType(), (state_ty.as_pointer(), int64_ty.as_pointer()))
gen_int = ir.Function(ctx.module, gen_ty, name="__pnl_builtin_mt_rand_int32")
gen_int.attributes.add('argmemonly')
gen_int.attributes.add('alwaysinline')
block = gen_int.append_basic_block(name="entry")
builder = ir.IRBuilder(block)
builder.debug_metadata = LLVMBuilderContext.get_debug_location(gen_int, None)
state, out = gen_int.args
# Add function arg attributes
for a in state, out:
a.attributes.add('nonnull')
a.attributes.add('noalias')
array = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(0)])
pidx = builder.gep(state, [ctx.int32_ty(0), ctx.int32_ty(1)])
idx = builder.load(pidx)
cond = builder.icmp_signed(">=", idx, ctx.int32_ty(_MERSENNE_N))
with builder.if_then(cond, likely=False):
mag01 = ir.ArrayType(array.type.pointee.element, 2)([0, 0x9908b0df])
pmag01 = builder.alloca(mag01.type)
builder.store(mag01, pmag01)
with helpers.for_loop_zero_inc(builder,
ctx.int32_ty(_MERSENNE_N - _MERSENNE_M),
"first_half") as (b, kk):
pkk = b.gep(array, [ctx.int32_ty(0), kk])
pkk_1 = b.gep(array, [ctx.int32_ty(0), b.add(kk, ctx.int32_ty(1))])
val_kk = b.and_(b.load(pkk), pkk.type.pointee(0x80000000))
val_kk_1 = b.and_(b.load(pkk_1), pkk_1.type.pointee(0x7fffffff))
val = b.or_(val_kk, val_kk_1)
val_1 = b.and_(val, val.type(1))
pval_mag = b.gep(pmag01, [ctx.int32_ty(0), val_1])
val_mag = b.load(pval_mag)
val_shift = b.lshr(val, val.type(1))
kk_m = b.add(kk, ctx.int32_ty(_MERSENNE_M))
pval_kk_m = b.gep(array, [ctx.int32_ty(0), kk_m])
val_kk_m = b.load(pval_kk_m)
val = b.xor(val_kk_m, val_shift)
val = b.xor(val, val_mag)
b.store(val, pkk)
with helpers.for_loop(builder,
ctx.int32_ty(_MERSENNE_N - _MERSENNE_M),
ctx.int32_ty(_MERSENNE_N),
ctx.int32_ty(1), "second_half") as (b, kk):
pkk = b.gep(array, [ctx.int32_ty(0), kk])
is_last = b.icmp_unsigned( "==", kk, ctx.int32_ty(_MERSENNE_N - 1))
idx_1 = b.select(is_last, ctx.int32_ty(0), b.add(kk, ctx.int32_ty(1)))
pkk_1 = b.gep(array, [ctx.int32_ty(0), idx_1])
val_kk = b.and_(b.load(pkk), pkk.type.pointee(0x80000000))
val_kk_1 = b.and_(b.load(pkk_1), pkk.type.pointee(0x7fffffff))
val = b.or_(val_kk, val_kk_1)
val_1 = b.and_(val, val.type(1))
pval_mag = b.gep(pmag01, [ctx.int32_ty(0), val_1])
val_mag = b.load(pval_mag)
val_shift = b.lshr(val, val.type(1))
kk_m = b.add(kk, ctx.int32_ty(_MERSENNE_M - _MERSENNE_N))
pval_kk_m = b.gep(array, [ctx.int32_ty(0), kk_m])
val_kk_m = b.load(pval_kk_m)
val = b.xor(val_kk_m, val_shift)
val = b.xor(val, val_mag)
b.store(val, pkk)
builder.store(pidx.type.pointee(0), pidx)
# Get pointer and update index
idx = builder.load(pidx)
pval = builder.gep(array, [ctx.int32_ty(0), idx])
idx = builder.add(idx, idx.type(1))
builder.store(idx, pidx)
# Load and temper
val = builder.load(pval)
tmp = builder.lshr(val, val.type(11))
val = builder.xor(val, tmp)
tmp = builder.shl(val, val.type(7))
tmp = builder.and_(tmp, tmp.type(0x9d2c5680))
val = builder.xor(val, tmp)
tmp = builder.shl(val, val.type(15))
tmp = builder.and_(tmp, tmp.type(0xefc60000))
val = builder.xor(val, tmp)
tmp = builder.lshr(val, val.type(18))
val = builder.xor(val, tmp)
# val is now random 32bit integer
val = builder.zext(val, out.type.pointee)
builder.store(val, out)
builder.ret_void()
return gen_int
def get_data_type(self):
elem_type = self._elem_model.get_data_type()
return ir.ArrayType(elem_type, self._count)
def const_int(x):
return ir.Constant(int32_t, x)
double = ir.DoubleType()
N = 624
N_const = ir.Constant(int32_t, N)
# This is the same struct as rnd_state_t in _random.c.
rnd_state_t = ir.LiteralStructType([
# index
int32_t,
# mt[N]
ir.ArrayType(int32_t, N),
# has_gauss
int32_t,
# gauss
double,
# is_initialized
int32_t,
])
rnd_state_ptr_t = ir.PointerType(rnd_state_t)
def get_state_ptr(context, builder, name):
"""
Get a pointer to the given thread-local random state
(depending on *name*: "py" or "np").
If the state isn't initialized, it is lazily initialized with
# return array;
# generate the IR code
######################################
# the initial part: define module, function, basic block, etc
i32 = ir.IntType(32) #integer with 32 bits
i32_0 = ir.Constant(i32, 0)
i32_1 = ir.Constant(i32, 1)
i32_3 = ir.Constant(i32, 3)
#make a module
module = ir.Module(name="array_example")
# define function parameters for function "main"
return_type = ir.ArrayType(
i32, 3) #the return type is an array with 3 32-bit integers
argument_types = list() #can add ir.IntType(#), ir.FloatType() for arguments
func_name = "main"
#make a function
fnty = ir.FunctionType(return_type, argument_types)
main_func = ir.Function(module, fnty, name=func_name)
# append basic block named 'entry', and make builder
# blocks generally have 1 entry and exit point, with no branches within the block
block = main_func.append_basic_block('entry')
builder = ir.IRBuilder(block)
########################################
#array = [3,5,8]
def get_data_type(self):
ret = ir.ArrayType(self._be_type, self._fe_type.nitems)
return ret
def gen_composition_exec(self, composition, simulation=False):
with self._gen_composition_exec_context(
composition, simulation) as (builder, data, params, cond_gen):
state, _, comp_in, _, cond = builder.function.args
# Call input CIM
input_cim_w = composition._get_node_wrapper(composition.input_CIM)
input_cim_f = self.import_llvm_function(input_cim_w)
builder.call(input_cim_f, [state, params, comp_in, data, data])
# Call parameter CIM
param_cim_w = composition._get_node_wrapper(
composition.parameter_CIM)
param_cim_f = self.import_llvm_function(param_cim_w)
builder.call(param_cim_f, [state, params, comp_in, data, data])
if simulation is False and composition.enable_controller and \
composition.controller_mode == BEFORE:
assert composition.controller is not None
controller = composition._get_node_wrapper(
composition.controller)
controller_f = self.import_llvm_function(controller)
builder.call(controller_f,
[state, params, comp_in, data, data])
# Allocate run set structure
run_set_type = ir.ArrayType(ir.IntType(1), len(composition.nodes))
run_set_ptr = builder.alloca(run_set_type, name="run_set")
builder.store(run_set_type(None), run_set_ptr)
# Allocate temporary output storage
output_storage = builder.alloca(data.type.pointee,
name="output_storage")
iter_ptr = builder.alloca(self.int32_ty, name="iter_counter")
builder.store(self.int32_ty(0), iter_ptr)
loop_condition = builder.append_basic_block(
name="scheduling_loop_condition")
builder.branch(loop_condition)
# Generate a while not 'end condition' loop
builder.position_at_end(loop_condition)
run_cond = cond_gen.generate_sched_condition(
builder, composition.termination_processing[TimeScale.TRIAL],
cond, None)
run_cond = builder.not_(run_cond, name="not_run_cond")
loop_body = builder.append_basic_block(name="scheduling_loop_body")
exit_block = builder.append_basic_block(name="exit")
builder.cbranch(run_cond, loop_body, exit_block)
# Generate loop body
builder.position_at_end(loop_body)
zero = self.int32_ty(0)
any_cond = ir.IntType(1)(0)
# Calculate execution set before running the mechanisms
for idx, mech in enumerate(composition.nodes):
run_set_mech_ptr = builder.gep(
run_set_ptr, [zero, self.int32_ty(idx)],
name="run_cond_ptr_" + mech.name)
mech_cond = cond_gen.generate_sched_condition(
builder, composition._get_processing_condition_set(mech),
cond, mech)
ran = cond_gen.generate_ran_this_pass(builder, cond, mech)
mech_cond = builder.and_(mech_cond,
builder.not_(ran),
name="run_cond_" + mech.name)
any_cond = builder.or_(any_cond,
mech_cond,
name="any_ran_cond")
builder.store(mech_cond, run_set_mech_ptr)
for idx, mech in enumerate(composition.nodes):
run_set_mech_ptr = builder.gep(run_set_ptr,
[zero, self.int32_ty(idx)])
mech_cond = builder.load(run_set_mech_ptr,
name="mech_" + mech.name +
"_should_run")
with builder.if_then(mech_cond):
mech_w = composition._get_node_wrapper(mech)
mech_f = self.import_llvm_function(mech_w)
builder.block.name = "invoke_" + mech_f.name
# Wrappers do proper indexing of all structures
if len(mech_f.args
) == 5: # Mechanism wrappers have 5 inputs
builder.call(
mech_f,
[state, params, comp_in, data, output_storage])
else:
builder.call(mech_f, [
state, params, comp_in, data, output_storage, cond
])
cond_gen.generate_update_after_run(builder, cond, mech)
builder.block.name = "post_invoke_" + mech_f.name
# Writeback results
for idx, mech in enumerate(composition.nodes):
run_set_mech_ptr = builder.gep(run_set_ptr,
[zero, self.int32_ty(idx)])
mech_cond = builder.load(run_set_mech_ptr,
name="mech_" + mech.name + "_ran")
with builder.if_then(mech_cond):
out_ptr = builder.gep(
output_storage,
[zero, zero, self.int32_ty(idx)],
name="result_ptr_" + mech.name)
data_ptr = builder.gep(
data, [zero, zero, self.int32_ty(idx)],
name="data_result_" + mech.name)
builder.store(builder.load(out_ptr), data_ptr)
# Update step counter
with builder.if_then(any_cond):
builder.block.name = "inc_step"
cond_gen.bump_ts(builder, cond)
builder.block.name = "update_iter_count"
# Increment number of iterations
iters = builder.load(iter_ptr, name="iterw")
iters = builder.add(iters, self.int32_ty(1), name="iterw_inc")
builder.store(iters, iter_ptr)
max_iters = len(composition.scheduler.consideration_queue)
completed_pass = builder.icmp_unsigned("==",
iters,
self.int32_ty(max_iters),
name="completed_pass")
# Increment pass and reset time step
with builder.if_then(completed_pass):
builder.block.name = "inc_pass"
builder.store(zero, iter_ptr)
# Bumping automatically zeros lower elements
cond_gen.bump_ts(builder, cond, (0, 1, 0))
builder.branch(loop_condition)
builder.position_at_end(exit_block)
if simulation is False and composition.enable_controller and \
composition.controller_mode == AFTER:
assert composition.controller is not None
controller = composition._get_node_wrapper(
composition.controller)
controller_f = self.import_llvm_function(controller)
builder.call(controller_f,
[state, params, comp_in, data, data])
# Call output CIM
output_cim_w = composition._get_node_wrapper(
composition.output_CIM)
output_cim_f = self.import_llvm_function(output_cim_w)
builder.block.name = "invoke_" + output_cim_f.name
builder.call(output_cim_f, [state, params, comp_in, data, data])
return builder.function
def __init__(self, dmm, fe_type):
super(UnicodeCharSeq, self).__init__(dmm, fe_type)
charty = ir.IntType(numpy_support.sizeof_unicode_char * 8)
self._be_type = ir.ArrayType(charty, fe_type.count)
def gera_codigo(arvore, tabela_simbolos, sema_success):
global modulo
global info
# Define as variáveis globais e funções
for simbolo in tabela_simbolos:
# Se o simbolo for uma variavel
if (simbolo["simbolo_tipo"] == "variable"
and simbolo["escopo"] == "global"):
var_type = simbolo["tipo_valor"]
# Verifica se o tipo é inteiro
if (var_type == "inteiro"):
if (len(simbolo["dimensoes"]) == 0):
g = ir.GlobalVariable(modulo, ir.IntType(32),
simbolo["nome"])
if (len(simbolo["dimensoes"]) == 1):
g_type = ir.ArrayType(ir.IntType(32),
int(simbolo["dimensoes"][0]))
g = ir.GlobalVariable(modulo, g_type, simbolo["nome"])
info["variaveis_globais"].append(g)
# Verifica se o tipo é flutuante
elif (var_type == "flutuante"):
if (len(simbolo["dimensoes"]) == 0):
g = ir.GlobalVariable(modulo, ir.FloatType(),
simbolo["nome"])
if (len(simbolo["dimensoes"]) == 1):
g_type = ir.ArrayType(ir.FloatType(),
int(simbolo["dimensoes"][0]))
g = ir.GlobalVariable(modulo, g_type, simbolo["nome"])
g.linkage = "common"
g.align = 4
info["variaveis_globais"].append(g)
# Se o simbolo for uma funcao
elif (simbolo["simbolo_tipo"] == "function"):
if (simbolo["nome"] == "principal"):
simbolo["nome"] = "main"
# Lista de argumentos
arguments_list = []
if (len(simbolo["parametros"]) > 0):
for a in simbolo["parametros"]:
if (a["par_type"] == "inteiro"):
arguments_list.append(ir.IntType(32))
else:
arguments_list.append(ir.FloatType())
if (len(simbolo["return"]) > 0):
if (simbolo["return"][0]["ret_type"] == "inteiro"):
f_ret = ir.IntType(32)
else:
f_ret = ir.FloatType()
f_func = ir.FunctionType(f_ret, arguments_list)
f = ir.Function(modulo, f_func, name=simbolo["nome"])
entryBlock = f.append_basic_block('entry')
builder = ir.IRBuilder(entryBlock)
else:
f_func = ir.FunctionType(ir.VoidType(), arguments_list)
f = ir.Function(modulo, f_func, name=simbolo["nome"])
entryBlock = f.append_basic_block('entry')
builder = ir.IRBuilder(entryBlock)
for i in range(len(f.args)):
f.args[i].name = simbolo["parametros"][i]["par_name"]
funcoes.append({
"function": f,
"builder": builder,
"arguments": f.args
})
# Chama a funcao recursiva que passa pela arvore
passar_por_arvore(arvore, funcoes)
file = open('modulo.ll', 'w')
file.write(str(modulo))
file.close()
print(modulo)