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()
