def __init__(self, **kwargs): self.info = {"global_variables": []} self.local_vars = [] self.aux = [] self.functions = [] self.module = ir.module.Module() llvm.initialize() llvm.initialize_all_targets() llvm.initialize_native_target() llvm.initialize_native_asmprinter() self.module = ir.Module('module.bc') self.module.triple = llvm.get_default_triple() target = llvm.Target.from_triple(self.module.triple) target_machine = target.create_target_machine() self.module.data_layout = target_machine.target_data self.escrevaInteiro = ir.Function(self.module, ir.FunctionType( ir.VoidType(), [ir.IntType(32)]), name="escrevaInteiro") self.escrevaFlutuante = ir.Function(self.module, ir.FunctionType( ir.VoidType(), [ir.FloatType()]), name="escrevaFlutuante") self.leiaInteiro = ir.Function(self.module, ir.FunctionType(ir.IntType(32), []), name="leiaInteiro") self.leiaFlutuante = ir.Function(self.module, ir.FunctionType(ir.FloatType(), []), name="leiaFlutuante")
def main(): if (len(sys.argv) < 2): print("ERRO - Por Favor Informe Um Arquivo .tpp") else: file = open(sys.argv[1], 'r', encoding='utf-8') sin = Sintatica(file.read(), Lexica().tokens) dot = Digraph(comment='TREE') Tree().printTree(sin.ast, dot) #dot.render('out/sintatica/normal.gv', view=True) Tree().poda(sin.ast) dot = Digraph(comment='TREE') Tree().printTreeCut(sin.ast, dot) #dot.render('out/semantica/poda.gv', view=True) sema = Semantica() sema.percorrerTree(sin.ast) sema.verificacoes() #sema.printTabSymbols() llvm.initialize() llvm.initialize_all_targets() llvm.initialize_native_target() llvm.initialize_native_asmparser() modulo = ir.Module(sys.argv[1]) modulo.triple = llvm.get_process_triple() target = llvm.Target.from_triple(modulo.triple) targetMachine = target.create_target_machine() modulo.data_layout = targetMachine.target_data Geracao().percorrer(sin.ast, modulo) arquivo = open('teste.ll', 'w') arquivo.write(str(modulo)) arquivo.close() print(modulo)
def __init__(self, code): self.semantica = Semantica(code) self.arvore = self.semantica.ast llvm.initialize() llvm.initialize_all_targets() llvm.initialize_native_target() llvm.initialize_native_asmprinter() self.module = ir.Module('meu_modulo.bc') self.module.triple = llvm.get_process_triple() target = llvm.Target.from_triple(self.module.triple) target_machine = target.create_target_machine() self.module.data_layout = target_machine.target_data #llvm.shutdown() self.variaveis = [] self.variaveisGlobais = [] self.escopo = "global" self.funcs = [] self.andaArvore(self.arvore) self.funcllvm = '' self.endBlock = '' arquivo = open('meu_modulo.ll', 'w') arquivo.write(str(self.module)) arquivo.close() print(self.module)
def __init__(self, tree: Program, symbol_table: SymbolTable, source_file: str) -> None: llvm.initialize() llvm.initialize_all_targets() llvm.initialize_all_asmprinters() self.tree = tree self.codegen = CodeGenerator(symbol_table) self.source_file = source_file self.target = llvm.Target.from_triple(llvm.get_default_triple())
def _binding_initialize(): global __initialized if not __initialized: binding.initialize() if not ptx_enabled: # native == currently running CPU. ASM printer includes opcode emission binding.initialize_native_target() binding.initialize_native_asmprinter() else: binding.initialize_all_targets() binding.initialize_all_asmprinters() __initialized = True
def llvm_get_target(triple_or_target=None): global __llvm_initialized if not __llvm_initialized: # Lazy initialisation llvm.initialize() llvm.initialize_all_targets() llvm.initialize_all_asmprinters() __llvm_initialized = True if isinstance(triple_or_target, llvm.Target): return triple_or_target if triple_or_target is None: return llvm.Target.from_default_triple() return llvm.Target.from_triple(triple_or_target)
def __init__(self): llvm.initialize() llvm.initialize_all_targets() llvm.initialize_native_target() llvm.initialize_native_asmprinter() self.module = None self._llvmmod = llvm.parse_assembly("") self.target = llvm.Target.from_default_triple() self.cpu = llvm.get_host_cpu_name() self.cpu_features = llvm.get_host_cpu_features() self.target_machine = self.target.create_target_machine( cpu=self.cpu, features=self.cpu_features.flatten(), opt=2) llvm.check_jit_execution() self.ee = llvm.create_mcjit_compiler(self.llvmmod, self.target_machine) self.ee.finalize_object() self.fptr = None
def compile_IR(ir): """Return execution engine with IR compiled in. Parameters ---------- ir : str Specify LLVM IR code as a string. Returns ------- engine : Execution engine. Examples -------- To get the address of the compiled functions, use:: addr = engine.get_function_address("<function name>") """ triple = re.search(r'target\s+triple\s*=\s*"(?P<triple>[-\d\w\W_]+)"\s*$', ir, re.M).group('triple') # Create execution engine llvm.initialize() llvm.initialize_all_targets() llvm.initialize_all_asmprinters() target = llvm.Target.from_triple(triple) target_machine = target.create_target_machine() backing_mod = llvm.parse_assembly("") engine = llvm.create_mcjit_compiler(backing_mod, target_machine) # Create LLVM module and compile mod = llvm.parse_assembly(ir) mod.verify() engine.add_module(mod) engine.finalize_object() engine.run_static_constructors() return engine
def main(): global root, func_table, var_table, module arg = sys.argv[1] if not arg.endswith('.tpp'): raise IOError("Not a tpp file!") data = open(arg, 'r') source_file = data.read() data.close() tree = SemanticAnalyzer(source_file) root = tree.root func_table = tree.func_table var_table = tree.var_table llvm.initialize() llvm.initialize_all_targets() llvm.initialize_native_target() llvm.initialize_native_asmprinter() module = ir.Module('meu_modulo.bc') module.triple = llvm.get_process_triple() target = llvm.Target.from_triple(module.triple) target_machine = target.create_target_machine() module.data_layout = target_machine.target_data generate_code() tree.set_atribution_asto() tree.export_tree() arquivo = open('atribuicao.ll', 'w') arquivo.write(str(module)) arquivo.close() print(module) llvm.shutdown()
from llvmlite import ir from llvmlite import binding as llvm from semantica import * llvm.initialize() llvm.initialize_all_targets() llvm.initialize_native_target() llvm.initialize_native_asmprinter() module = ir.Module('meu_modulo.bc') module.triple = llvm.get_default_triple() target = llvm.Target.from_triple(module.triple) target_machine = target.create_target_machine() llvm.load_library_permanently('./io.so') module.data_layout = target_machine.target_data escrevaInteiro = ir.Function(module,ir.FunctionType(ir.VoidType(), [ir.IntType(32)]),name="escrevaInteiro") escrevaFlutuante = ir.Function(module,ir.FunctionType(ir.VoidType(),[ir.FloatType()]),name="escrevaFlutuante") leiaInteiro = ir.Function(module,ir.FunctionType(ir.IntType(32),[]),name="leiaInteiro") leiaFlutuante = ir.Function(module,ir.FunctionType(ir.FloatType(),[]),name="leiaFlutuante") vetTabela = [] # funcNow = { # "nome": None, # "escopo": "global", # "type": None, # "funcCabecalho": None,
# # The Autobentifier # # Copyright (c) 2020, Arm Limited. All rights reserved. # SPDX-License-Identifier: BSD-3-Clause # from llvmlite import binding binding.initialize() binding.initialize_all_targets() binding.initialize_all_asmprinters() with open("demo.elf.ll") as fp: x = fp.read() xl = binding.parse_assembly(x)
def test_llvm_lite_ptx_pycuda(): # Create some useful types double = ir.DoubleType() fnty = ir.FunctionType(ir.VoidType(), (double, double, double.as_pointer())) # Create an empty module... module = ir.Module(name=__file__) # and declare a function named "fpadd" inside it func = ir.Function(module, fnty, name="fpadd") # Now implement basic addition # basic blocks are sequences of instructions that have exactly one # entry point and one exit point (no control flow) # We only need one in this case # See available operations at: # http://llvmlite.readthedocs.io/en/latest/ir/builder.html#instruction-building block = func.append_basic_block(name="entry") builder = ir.IRBuilder(block) a, b, res = func.args result = builder.fadd(a, b, name="res") builder.store(result, res) builder.ret_void() # Add kernel mark metadata module.add_named_metadata( "nvvm.annotations", [func, "kernel", ir.IntType(32)(1)]) # Uncomment to print the module IR. This prints LLVM IR assembly. # print("LLVM IR:\n", module) binding.initialize() binding.initialize_all_targets() binding.initialize_all_asmprinters() capability = pycuda_default.device.compute_capability() # Create compilation target, use default triple target = binding.Target.from_triple("nvptx64-nvidia-cuda") target_machine = target.create_target_machine(cpu="sm_{}{}".format( capability[0], capability[1]), codemodel='small') mod = binding.parse_assembly(str(module)) mod.verify() ptx = target_machine.emit_assembly(mod) # Uncomment to print generated x86 assembly # print("PTX assembly:\n", ptx) ptx_mod = pycuda.driver.module_from_buffer(ptx.encode()) cuda_func = ptx_mod.get_function('fpadd') # Run the function via ctypes a = np.float64(10.0) b = np.float64(3.5) res = np.empty(1, dtype=np.float64) dev_res = pycuda.driver.Out(res) cuda_func(a, b, dev_res, block=(1, 1, 1)) assert res[0] == (a + b)
def initialize_llvm(): llvm.initialize() llvm.initialize_all_targets() llvm.initialize_all_asmprinters()