def visit_Instruction(self, instr): if instr.type == ir.IntType(64): if instr.opname in ['srem', 'urem', 'sdiv', 'udiv']: name = 'numba_{op}'.format(op=instr.opname) fn = self.module.globals.get(name) # Declare the function if it doesn't already exist if fn is None: opty = instr.type sdivfnty = ir.FunctionType(opty, [opty, opty]) fn = ir.Function(self.module, sdivfnty, name=name) # Replace the operation with a call to the builtin repl = ir.CallInstr(parent=instr.parent, func=fn, args=instr.operands, name=instr.name) instr.parent.replace(instr, repl)
def externfuncdecl(self, name, node): for func in self.module.functions: if func.name == name: self.define(name, func, 1) return return_type = node.return_type parameters = node.parameters varargs = node.varargs ret_type = type_map[return_type.value] args = [type_map[param.value] for param in parameters.values()] func_type = ir.FunctionType(ret_type, args, varargs) func_type.parameters = parameters if hasattr(return_type, 'func_ret_type') and return_type.func_ret_type: func_type.return_type = func_type.return_type(type_map[return_type.func_ret_type.value], [return_type.func_ret_type.value]).as_pointer() func = ir.Function(self.module, func_type, name) self.define(name, func, 1)
def generateCode(self, breakBlock=None): #print "generating code for funcdecl",self.name, self.arglist argtypelist = [] argnamelist = [] for arg in self.arglist: try: argType = makeArgumentType(arg.typestr) except ValueError: print "in funcDecl", self.name raise argtypelist.append(argType) argnamelist.append(arg.name) functype = ir.FunctionType(self.rettype, argtypelist) foundDup = False for f in gLlvmModule.functions: if self.name == f.name: foundDup = True funcobj = f break if not foundDup: funcobj = ir.Function(gLlvmModule, functype, name=self.name) #print "made a function declaration for name:", self.name self.llvmNode = funcobj if funcobj.name != self.name: # something already exists # don't allow redef or redecl #funcobj.delete() funcobj = gLlvmModule.get_function_named(self.name) # if the function already has a body, this is bad. if not funcobj.is_declaration: raise RuntimeError('Redefinition of function: ' + self.name) # if f took a different number of args, that's bad (callee?) if len(funcobj.args) != len(self.arglist): raise RuntimeError('wrong args') for arg, argName in zip(funcobj.args, argnamelist): #print "assigning",argName,arg arg.name = argName gNamedValues[argName] = arg return funcobj
def build_initial_ir(symbol_table: SymbolTable, context: CodegenContext): assert 'free' not in symbol_table for type_identifier, builtin_type in SLEEPY_TYPES.items(): assert type_identifier not in symbol_table symbol_table[ type_identifier] = TypeTemplateSymbol.make_concrete_type_symbol( builtin_type) if builtin_type == SLEEPY_UNIT: continue # add destructor destructor_signature = BuiltinOperationFunctionSignature( identifier='free', placeholder_template_types=[], return_type=SLEEPY_UNIT, arg_identifiers=['var'], arg_types=[builtin_type], arg_type_narrowings=[SLEEPY_NEVER], instruction=lambda builder, value: SLEEPY_UNIT.unit_constant()) symbol_table.add_overload('free', destructor_signature) if context.emits_ir: context.ir_func_malloc = ir.Function(context.module, ir.FunctionType( LLVM_VOID_POINTER_TYPE, [LLVM_SIZE_TYPE]), name='malloc') # TODO: currently, some builtin free() functions are not inlined. # This means that we need to add debug information to these functions, but they do not have any line numbers. # We use this dummy here. builtin_pos = TreePosition('', 0, 0) builtin_symbols = { 'Str': _make_str_symbol, 'Ptr': _make_ptr_symbol, 'RawPtr': _make_raw_ptr_symbol, 'Ref': _make_ref_symbol, 'bitcast': _make_bitcast_symbol } with context.use_pos(builtin_pos): for symbol_identifier, setup_func in builtin_symbols.items(): assert symbol_identifier not in symbol_table symbol = setup_func(symbol_table=symbol_table, context=context) symbol_table[symbol_identifier] = symbol _make_builtin_operator_functions(symbol_table)
def test_helper_is_close(mode): 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, ctx.int32_ty]) # Create clamp function custom_name = ctx.get_unique_name("all_close") function = ir.Function(ctx.module, func_ty, name=custom_name) in1, in2, out, count = function.args block = function.append_basic_block(name="entry") builder = ir.IRBuilder(block) index = None with pnlvm.helpers.for_loop_zero_inc(builder, count, "compare") as (b1, index): val1_ptr = b1.gep(in1, [index]) val2_ptr = b1.gep(in2, [index]) val1 = b1.load(val1_ptr) val2 = b1.load(val2_ptr) close = pnlvm.helpers.is_close(b1, val1, val2) out_ptr = b1.gep(out, [index]) out_val = b1.select(close, ctx.float_ty(1), ctx.float_ty(0)) b1.store(out_val, out_ptr) builder.ret_void() vec1 = copy.deepcopy(vector) tmp = np.random.rand(DIM_X) tmp[0::2] = vec1[0::2] vec2 = np.asfarray(tmp) assert len(vec1) == len(vec2) res = np.empty_like(vec2) ref = np.isclose(vec1, vec2) bin_f = pnlvm.LLVMBinaryFunction.get(custom_name) if mode == 'CPU': ct_ty = pnlvm._convert_llvm_ir_to_ctype(double_ptr_ty) ct_vec1 = vec1.ctypes.data_as(ct_ty) ct_vec2 = vec2.ctypes.data_as(ct_ty) ct_res = res.ctypes.data_as(ct_ty) bin_f(ct_vec1, ct_vec2, ct_res, DIM_X) else: bin_f.cuda_wrap_call(vec1, vec2, res, np.int32(DIM_X)) assert np.array_equal(res, ref)
def _codegenPrototypeAST(self, node): funcName = node.name # Create a function type funcType = ir.FunctionType(ir.DoubleType(), [ir.DoubleType()] * len(node.argNames)) # If a function with this name already exists in the module... if funcName in self.module.globals: # We do not allow redeclaration yet. Potentially worth changing later... raise CodegenError('Function/Global name collision', funcName) else: func = ir.Function(self.module, funcType, funcName) # Set function argument names from AST for i, arg in enumerate(func.args): arg.name = node.argNames[i] self.functionSymbolTable[arg.name] = arg return func
def gen_anonymous_function(ast, nst, ctx): params, _, body = ast fname = ast.fname nst.enterScope(fname) ftype = llvm_fun_type(ast.type, nst, ctx) print(ftype) func = ir.Function(ctx['mod'], ftype, name=fname) entry = func.append_basic_block('entry') for arg, name in zip(func.args, params.names): arg.name = name nst.currentScope[name].llvm_info = arg builder = ir.IRBuilder(entry) new_ctx = {'builder': builder, **ctx} codegen(params, nst, new_ctx) codegen(body, nst, new_ctx) nst.exitScope() return func
def declare_functions(self, node): for fn_symbol in self.context.symbols: if isinstance(fn_symbol, FunctionSymbol): parameters = [] for var_symbol in self.context.symbols: if isinstance( var_symbol, VarSymbol ) and var_symbol.scope == fn_symbol.name and var_symbol.parameter: parameters.append( self.type_to_llvmlite_type(var_symbol.type_, var_symbol.index_list)) type_ = self.type_to_llvmlite_type(fn_symbol.type_, []) t_func = ir.FunctionType(type_, parameters) func = ir.Function(self.module, t_func, name=fn_symbol.name)
def register_readln(self): read_type = ir.FunctionType(ir.VoidType(), (ir.IntType(32),)) c_read_type = CFUNCTYPE(c_void_p, c_int32) c_read = c_read_type(wirte) read_address = cast(c_read, c_void_p).value read_func_type = ir.FunctionType(ir.VoidType(), (ir.IntType(32),)) read_func = ir.Function(self.module, read_func_type, 'readln') builder = ir.IRBuilder(read_func.append_basic_block('entry')) read_f = builder.inttoptr(ir.Constant(ir.IntType(64), read_address), read_func_type.as_pointer(), name='read_f') arg = read_func.args[0] arg.name = 'arg0' call = builder.call(read_f, [arg]) builder.ret_void() self.GenTable.add_function(func_name='readln', func_block=read_func, scope_id=self.scope_id)
def import_llvm_function(self, fun, *, tags: frozenset = frozenset()) -> ir.Function: """ Get function handle if function exists in current modele. Create function declaration if it exists in a older module. """ if isinstance(fun, str): f = _find_llvm_function(fun, _all_modules | {self.module}) else: f = self.gen_llvm_function(fun, tags=tags) # Add declaration to the current module if f.name not in self.module.globals: decl_f = ir.Function(self.module, f.type.pointee, f.name) assert decl_f.is_declaration return decl_f return f
def _headers(self): int8 = ir.IntType(8).as_pointer() fmt = "%i\n\0" c_fmt = ir.Constant(ir.ArrayType(ir.IntType(8), len(fmt)), bytearray(fmt.encode("utf8"))) global_fmt = ir.GlobalVariable(self.module, c_fmt.type, name="fstr") global_fmt.linkage = 'internal' global_fmt.global_constant = True global_fmt.initializer = c_fmt ty = ir.FunctionType(ir.IntType(32), [int8], var_arg=True) printf = ir.Function(self.module, ty, name="printf") self.env["ftm"] = global_fmt self.env["printf"] = printf
def visitCompilationUnit(self, ctx: SoLangParser.CompilationUnitContext): # global function table # functions[function-name] = function-pointer self.functions = {} # global variable table # variables[function-name][variable-name] = variable-pointer self.variables = {} self.current_function = '' # llvm init llvm.initialize() llvm.initialize_native_target() llvm.initialize_native_asmprinter() # set target target = llvm.Target.from_default_triple() # define types self.i64 = ir.IntType(64) self.f64 = ir.FloatType() self.module = ir.Module(name='sokoide_module') self.module.triple = target.triple # function prototype (external linkage implemented in builtin.c) for # void write(int64_t) ftype_write = ir.FunctionType(ir.VoidType(), [self.i64]) self.fn_write = ir.Function(self.module, ftype_write, name='write') self.visitChildren(ctx) # generate code llvm_ir = str(self.module) llvm_ir_parsed = llvm.parse_assembly(llvm_ir) # optimizer if self.optimize: pmb = llvm.create_pass_manager_builder() pmb.opt_level = 1 pm = llvm.create_module_pass_manager() pmb.populate(pm) pm.run(llvm_ir_parsed) with open('build/out.ll', 'w') as f: f.write(str(llvm_ir_parsed)) return None
def dynamic_array_length(self, dyn_array_ptr, array_type): # START dyn_array_length_type = ir.FunctionType(type_map[INT], [dyn_array_ptr]) dyn_array_length = ir.Function(self.module, dyn_array_length_type, '{}_array_length'.format(array_type)) dyn_array_length_entry = dyn_array_length.append_basic_block('entry') builder = ir.IRBuilder(dyn_array_length_entry) self.builder = builder builder.position_at_end(dyn_array_length_entry) array_ptr = builder.alloca(dyn_array_ptr) builder.store(dyn_array_length.args[0], array_ptr) size_ptr = builder.gep(builder.load(array_ptr), [zero_32, zero_32], inbounds=True) # CLOSE builder.ret(builder.load(size_ptr))
def test_fixed_dimensions__pnl_builtin_vxm(mode): # The original builtin mxv function binf = pnlvm.LLVMBinaryFunction.get("__pnl_builtin_vxm") orig_res = np.empty_like(llvm_res) if mode == 'CPU': ct_in_ty, ct_mat_ty, _, _, ct_res_ty = binf.byref_arg_types ct_vec = vector.ctypes.data_as(ctypes.POINTER(ct_in_ty)) ct_mat = matrix.ctypes.data_as(ctypes.POINTER(ct_mat_ty)) ct_res = orig_res.ctypes.data_as(ctypes.POINTER(ct_res_ty)) binf.c_func(ct_vec, ct_mat, x, y, ct_res) else: binf.cuda_wrap_call(vector, matrix, np.int32(x), np.int32(y), orig_res) custom_name = None with pnlvm.LLVMBuilderContext() as ctx: custom_name = ctx.get_unique_name("vxsqm") double_ptr_ty = ctx.convert_python_struct_to_llvm_ir(1.0).as_pointer() func_ty = ir.FunctionType( ir.VoidType(), (double_ptr_ty, double_ptr_ty, double_ptr_ty)) # get builtin IR builtin = ctx.import_llvm_function("__pnl_builtin_vxm") # Create square vector matrix multiply function = ir.Function(ctx.module, func_ty, name=custom_name) _x = ctx.int32_ty(x) _v, _m, _o = function.args block = function.append_basic_block(name="entry") builder = ir.IRBuilder(block) builder.call(builtin, [_v, _m, _x, _x, _o]) builder.ret_void() binf2 = pnlvm.LLVMBinaryFunction.get(custom_name) new_res = np.empty_like(llvm_res) if mode == 'CPU': ct_res = new_res.ctypes.data_as(ctypes.POINTER(ct_res_ty)) binf2(ct_vec, ct_mat, ct_res) else: binf2.cuda_wrap_call(vector, matrix, new_res) assert np.array_equal(orig_res, new_res)
def visit_JapycFunction(self, node): # hard coded return value, hardcoded 64 bit integers function_type = ir.FunctionType(ir.VoidType(), [ir.IntType(64) for _ in node.args]) fn = ir.Function(self.module, function_type, name=node.name) block = fn.append_basic_block(name='entry') self.functions[node.name] = fn self.builder = ir.IRBuilder(block) # lookup table for function arguments self.function_arguments = { ast_arg.name: llvm_arg for ast_arg, llvm_arg in zip(node.args, fn.args) } self._recurse(node.body) self.builder.ret_void()
def llvm_declaracao_funcao(self, modulo, filho, nome, tipo_de_retorno): if nome == "principal": nome = "main" if tipo_de_retorno == "inteiro": tipo_de_retorno = ir.IntType(32) elif tipo_de_retorno == "flutuante": tipo_de_retorno = ir.FloatType() tipo_da_funcao = ir.FunctionType(tipo_de_retorno, []) funcao = ir.Function(modulo, tipo_da_funcao, name=nome) self.lista_ponteiros_funcoes.append(funcao) bloco_de_entrada = funcao.append_basic_block('%s.start' % nome) self.builder = ir.IRBuilder(bloco_de_entrada) retorna = self.builder.alloca(tipo_de_retorno, name='return') self.lista_ponteiros_variaveis.append(retorna) corpo = filho.child[1].child[1] self.resolve_corpo(corpo, modulo, self.builder)
def make_lookup(name,ary): #build tables func = ir.Function(module, lfnty, name=name) func.attributes.personality = pers func.attributes.add("alwaysinline") func.attributes.add("uwtable") block = func.append_basic_block(name="entry") builder = ir.IRBuilder(block) g,v = emph.CreateMinimalPerfectHash({ary[i]:i for i in range(len(ary))}) l = len(g) g = builder.bitcast(get_int_array(g),ir.ArrayType(int32,0).as_pointer()) v = builder.bitcast(get_int_array(v),ir.ArrayType(int32,0).as_pointer()) strs = builder.bitcast(get_constant(ary),make_tuple_type(0)[1]) builder.ret(builder.call(local_lookup,(func.args[0],strs,g,v,int32(l)))) return func
def declaracao_funcao_main(modulo, name, funcao_soma, tipo_retorno_funcao=ir.VoidType()): # Declarando função tipo_funcao = ir.FunctionType(tipo_retorno_funcao, []) funcao_declarada = ir.Function(modulo, tipo_funcao, name=name) bloco_inicio = funcao_declarada.append_basic_block('%s.start' % name) bloco_fim = funcao_declarada.append_basic_block('%s.end' % name) builder = ir.IRBuilder(bloco_inicio) # Entrando na função funcao_declarada with builder.goto_entry_block(): # inteiro: a, b a = declara_local_var(builder, ir.IntType(32), 'a') b = declara_local_var(builder, ir.IntType(32), 'b') # leia(a) leia = declara_funcao_externa(modulo, 'scanf') args = [declara_string_global(modulo, '%d\0'), a] chama_funcao(builder, leia, args) # leia(b) leia = declara_funcao_externa(modulo, 'scanf') args = [declara_string_global(modulo, '%d\0'), b] chama_funcao(builder, leia, args) # escreva(soma(a,b)) args = [builder.load(a), builder.load(b)] res = chama_funcao(builder, funcao_soma, args) escreva = declara_funcao_externa(modulo, 'printf') args = [declara_string_global(modulo, '%d\n\0'), res] chama_funcao(builder, escreva, args) # Vai para o final da função builder.branch(bloco_fim) # Finaliza a função funcao_declarada with builder.goto_block(bloco_fim): builder.ret_void() return funcao_declarada
def function_decl(self, node): name, paralist, ret = self.function_head(node.children[0]) namelist = [] ir_type_list = [] for t in paralist: if t[0][0] == "var": for i in range(1, len(t[0])): ir_type_list.append(t[1].as_pointer()) namelist.append(("var", t[0][i])) else: for i in range(1, len(t[0])): ir_type_list.append(t[1]) namelist.append(("val", t[0][i])) ret_ir_type = type_t[ node.children[0].children[-1].children[0].name.upper()] func_type = ir.FunctionType(ret_ir_type, ir_type_list) func = ir.Function(self.module, func_type, name=name) self.symbol_table.insert([name, func]) self.symbol_table.create_tab() stored_builder = self.builder block = func.append_basic_block(name=name) self.builder = ir.IRBuilder(block) retaddr = self.builder.alloca(ret_ir_type) self.symbol_table.insert([name + "_return", retaddr]) func_args = func.args for i in range(len(func_args)): if namelist[i][0] == "val": addr = self.builder.alloca(ir_type_list[i]) self.builder.store(func_args[i], addr) self.symbol_table.insert([namelist[i][1], addr]) if namelist[i][0] == "var": addr = func_args[i] self.symbol_table.insert([namelist[i][1], addr]) self.subroutine(node.children[2]) retval = self.builder.load(retaddr) self.builder.ret(retval) self.builder = stored_builder self.symbol_table.pop()
def define_print(self, dyn_array_ptr): # START func_type = ir.FunctionType(type_map[VOID], [dyn_array_ptr]) func = ir.Function(self.module, func_type, 'print') entry_block = func.append_basic_block('entry') builder = ir.IRBuilder(entry_block) self.builder = builder builder.position_at_end(entry_block) zero_length_check_block = func.append_basic_block('zero_length_check') non_zero_length_block = func.append_basic_block('non_zero_length') cond_block = func.append_basic_block('check_if_done') body_block = func.append_basic_block('print_it') exit_block = func.append_basic_block('exit') array_ptr = builder.alloca(dyn_array_ptr) builder.store(func.args[0], array_ptr) # BODY builder.position_at_end(entry_block) length = builder.call(self.module.get_global('i64.array.longitud'), [builder.load(array_ptr)]) builder.branch(zero_length_check_block) builder.position_at_end(zero_length_check_block) cond = builder.icmp_signed(LESS_THAN_OR_EQUAL_TO, zero, length) builder.cbranch(cond, non_zero_length_block, exit_block) builder.position_at_end(non_zero_length_block) position_ptr = builder.alloca(type_map[INT]) builder.store(zero, position_ptr) builder.branch(cond_block) builder.position_at_end(cond_block) cond = builder.icmp_signed(LESS_THAN, builder.load(position_ptr), length) builder.cbranch(cond, body_block, exit_block) builder.position_at_end(body_block) char = builder.call(self.module.get_global('i64.array.ver'), [builder.load(array_ptr), builder.load(position_ptr)]) builder.call(self.module.get_global('putchar'), [char]) add_one = builder.add(one, builder.load(position_ptr)) builder.store(add_one, position_ptr) builder.branch(cond_block) # CLOSE builder.position_at_end(exit_block) builder.call(self.module.get_global('putchar'), [ten]) builder.ret_void()
def define_variaveis_auxiliares(self): self.valores = {} self.valoresExpressoes = {} self.valoresLeia = {} self.valoresRetorno = {} self.valoresRepita = {} self.valoresStore = {} self.escopoVar = [] self.builder = None self.escopo = "global" self.escopoRepita = None self.funcao = None self.var = None #self.leiaFlutuante = ir.Function(self.modulo, ir.FunctionType(ir.FloatType(), []), 'leiaFlutuante') self.leiaInteiro = ir.Function(self.modulo, ir.FunctionType(ir.IntType(32), []), 'leiaInteiro')
def fix_powi_calls(mod): """Replace llvm.powi.f64 intrinsic because we don't have compiler-rt. """ orig = mod.globals.get('llvm.powi.f64') if orig is not None: # Build a wrapper function for powi() to re-direct the intrinsic call # to pow(). powinstr = mod.declare_intrinsic('llvm.pow', [ir.DoubleType()]) repl = ir.Function(mod, orig.function_type, name=".numba.powi_fix") repl.linkage = 'internal' builder = ir.IRBuilder(repl.append_basic_block()) base, power = repl.args power = builder.sitofp(power, ir.DoubleType()) call = builder.call(powinstr, [base, power]) builder.ret(call) # Replace all calls in the module ir.replace_all_calls(mod, orig, repl)
def code_gen(self, module, bb=None): ret_type = get_llvm_prm_type(self.type) args_type = [get_llvm_prm_type(arg.type) for arg in self.args] ty_func = ir.FunctionType(ret_type, args_type) func = ir.Function(module, ty_func, self.name) self.func = func for i in range(len(self.args)): func.args[i].name = self.args[i].name self.args[i].ptr = func.args[i] bb = func.append_basic_block("entry") builder = ir.IRBuilder(bb) for op in self.order_operations: op.code_gen(func, builder)
def walk_ast(self, scope, builder): try: scope.add_callable(self) except ScopeException: Exit.REDECLARED_NAME_ERROR(self.lineno, self.globid) self.type = self.ret_type if self.decls: self.func_type = ir.FunctionType( self.ir_type, [decl.ir_type for decl in self.decls], var_arg=self.var_arg) else: self.func_type = ir.FunctionType(self.ir_type, [], var_arg=self.var_arg) self.ptr = ir.Function(builder, self.func_type, name=self.globid) scope.add_ptr(self.globid, self.ptr) if self.decls: self.decls.walk_ast(scope.copy(), builder) super().walk_ast(scope.copy(), builder)
def generate(self): func_name = self.name func_ty = ir.FunctionType(self.cg.int64, [self.cg.int64] * len(self.arg_names), False) if func_name in self.module.globals: func = self.module[func_name] if not isinstance(func, ir.Function): raise CodeGenError('Function / Global name collision', func_name) if not func.is_declaration(): raise CodeGenError('Redefinition of {0}', func_name) if len(func.function_type.args) != len(self.arg_names): raise CodeGenError( 'Redefinition with different number of arguments') else: func = ir.Function(self.module, func_ty, func_name) return func
def add_function(self, mir_function): """Add the specified function to the current module.""" # Add only if it doesn't exist yet. try: if mir_function not in self.functions: self.functions.add(mir_function) mir_function.module = self fty = mir_function._llvm_type._ptr name = mir_function.name #llvm_func_def = self._ptr.add_function(fty, name) llvm_func_def = ir.Function(self._ptr, fty, name) mir_function._llvm_definition = llvm_func_def except Exception, err: raise MiddleIrModuleException(err)
def externs(extern, module, *sysArgs): returnType = ir_type(extern["ret_type"]) args = list() if "tdecls" in extern: for arg in extern["tdecls"]["types"]: args.append(ir_type(arg)) if extern["globid"] == "getarg": getArg(module, *sysArgs) elif extern["globid"] == "getargf": getArgf(module, *sysArgs) pass else: fnty = ir.FunctionType(returnType, args) func = ir.Function(module, fnty, name=extern["globid"])
def get_extract_func(high, low, bigwidth): smallwidth = high - low + 1 t = (smallwidth, bigwidth) if t not in get_extract_func.funcs: typ = ir.FunctionType( ir.IntType(smallwidth), [ir.IntType(64), ir.IntType(64), ir.IntType(bigwidth)]) func = ir.Function(module, typ, "smt.extract.i%d.i%d" % (bigwidth, smallwidth)) func.attributes.add("readnone") func.attributes.add("norecurse") func.attributes.add("nounwind") get_extract_func.funcs[t] = func return get_extract_func.funcs[t]
def __init__(self): ''' Initialize llvm ''' self.binding = binding self.binding.initialize() self.binding.initialize_native_target() self.binding.initialize_native_asmprinter() # Declare module self.module = ir.Module() self.module.triple = self.binding.get_default_triple() # Declare main function func_type = ir.FunctionType(ir.VoidType(), [], False) base_func = ir.Function(self.module, func_type, name='main') block = base_func.append_basic_block() # Declare builder self.builder = ir.IRBuilder(block)
def __init__(self,nome,module,returnType,returnValue): self.retValue=None self.functionType=None self.functionDeclaration=None self.entryBlock=None self.endBlock=None self.builder=None self.variables={} if returnType=="inteiro": self.retValue = ir.Constant(ir.IntType(32),returnValue) self.functionType = ir.FunctionType(ir.IntType(32),()) elif returnType=="flutuante": self.retValue = ir.Constant(ir.FloatType(),returnValue) self.functionType = ir.FunctionType(ir.FloatType,()) self.functionDeclaration = ir.Function(module,self.functionType,name=nome) self.entryBlock = self.functionDeclaration.append_basic_block('entry') self.endBlock = self.functionDeclaration.append_basic_block('exit') self.builder = ir.IRBuilder(self.entryBlock)