def generate_code(module):
""" Generate code """
march = 'x86_64'
obj1 = api.ir_to_object([module], march)
obj2 = api.asm('crt0.asm', march)
obj3 = api.c3c(['crt0.c3'], [], march)
obj = api.link([obj1, obj2, obj3])
with open('test.oj', 'w') as f:
obj.save(f)
def xx_test_compiling():
# Convert Python to wasm
wasm_module = python_to_wasm(py3)
# Convert wasm to ppci
ppci_module = wasm.wasm_to_ir(wasm_module)
# Optimizer fails, or makes it slower ;)
# optimize(ppci_module, 2)
# Compile to native object
arch = get_current_arch()
ob = ir_to_object([ppci_module], arch, debug=True)
# Run in memory
native_module = codepage.load_obj(ob)
result = native_module.main()
assert result == 2741
def go():
generator = Generator()
module = generator.gen_module()
obj = ir_to_object([module], 'arm')
print(obj)
lhs = self.emit(ir.Binop(lhs, '*', rhs, 'prod', self.int_type))
product.ir_value = lhs
def get_value(self, value):
if isinstance(value, int):
ir_value = self.emit(ir.Const(value, 'constant', self.int_type))
elif isinstance(value, str):
ir_value = self.load_var(value)
else:
ir_value = value.ir_value
return ir_value
def load_var(self, var_name):
mem_loc = self.variables[var_name]
return self.emit(ir.Load(mem_loc, var_name, self.int_type))
tcfCompiler = TcfCompiler()
ir_module = tcfCompiler.compile('example.tcf')
obj1 = api.ir_to_object([ir_module], 'x86_64')
obj2 = api.c3c(['bsp.c3', 'io.c3'], [], 'x86_64')
obj3 = api.asm('linux.asm', 'x86_64')
obj = api.link([obj1, obj2, obj3], layout='layout.mmap')
print(obj)
with open('example.oj', 'w') as f:
obj.save(f)
api.objcopy(obj, 'code', 'elf', 'example')
ppci_module = wasm_to_ir(wasm_module, arch.info.get_type_info('ptr'))
# Optimizer fails, or makes it slower ;)
# optimize(ppci_module, 2)
this_dir = os.path.dirname(os.path.abspath(__file__))
# Generate a report:
html_report = os.path.join(this_dir, 'compilation_report.html')
with reporting.html_reporter(html_report) as reporter:
# Write IR code
f = StringIO()
irutils.print_module(ppci_module, file=f, verify=False)
print(f.getvalue())
# Compile to native object
ob = ir_to_object([ppci_module], arch, debug=True, reporter=reporter)
# Hack: fix the return type
ob.debug_info.functions[0].return_type = float
# Run in memory
native_module = codepage.load_obj(ob)
t0 = perf_counter()
result = native_module.main()
etime = perf_counter() - t0
print(f'native says {result} in {etime} s')
# Generate html page:
export_wasm_example(os.path.join(this_dir, 'prime_demo_page.html'), py3,
wasm_module)
f.write(data)
files = [
'clang.wasm',
'clang-format.wasm',
'runtime.wasm',
]
for local_filename in files:
url = 'https://tbfleming.github.io/cib/{}'.format(local_filename)
if not os.path.exists(local_filename):
download_file(url, local_filename)
with open('runtime.wasm', 'rb') as f:
# with open('clang-format.wasm', 'rb') as f:
wasm_module = Module(f.read())
print(wasm_module)
wasm_module.show_interface()
arch = get_arch('x86_64')
ptr_info = arch.info.get_type_info('ptr')
ir_module = wasm_to_ir(wasm_module, ptr_info)
print(ir_module)
print(ir_module.stats())
obj = ir_to_object([ir_module], arch)
with open('mandelbrot_compilation_report.html',
'w') as f, HtmlReportGenerator(f) as reporter:
with open('mandelbrot.py', 'r') as f:
mod = python_to_ir(f, imports={'puts': puts})
with open('mandelbrot.py', 'r') as f:
src = list(f)
reporter.annotate_source(src, mod)
verify_module(mod)
# print_module(mod)
obj_py = ir_to_object([mod], 'x86_64')
# print(obj_py)
c_glue = """
void mandelbrot();
void syscall(int nr, int a, int b, int c);
void exit(int status);
void putc(char c);
void puts(char *s);
int main()
{
mandelbrot();
/* As we don't have any C startup code in this example, and main is
the executable entrypoint, we can't just return, but have to
debug_db = debuginfo.DebugDb()
converter = PPCIGen()
ppci_module = converter.generate(wasm, debug_db=debug_db)
# Optimizer fails, or makes it slower ;)
# optimize(ppci_module, 2)
f = StringIO()
irutils.Writer(f).write(ppci_module, verify=False)
print(f.getvalue())
with open('c:/dev/report.html',
'w') as f, reporting.HtmlReportGenerator(f) as reporter:
ob = ir_to_object([ppci_module],
get_arch('x86_64:wincc'),
debug=True,
debug_db=debug_db,
reporter=reporter)
native_module = codepage.load_obj(ob)
t0 = perf_counter()
result = native_module.main()
etime = perf_counter() - t0
print(f'native says {result} in {etime} s')
##
f = StringIO()
pythonizer = ir2py.IrToPython(f)
pythonizer.header()
pythonizer.generate(ppci_module)
py_code = f.getvalue()
'memory',
('export', 'mem0ry'),
('data', 'abcd'),
),
)
print(wasm_module.to_string())
arch = get_current_arch()
ppci_module = wasm_to_ir(wasm_module, arch.info.get_type_info('ptr'))
ppci_module.display()
print('using this arch: ', arch)
f = io.StringIO()
txt_stream = TextOutputStream(f=f, add_binary=True)
obj = ir_to_object([ppci_module], arch, debug=True, outstream=txt_stream)
print(f.getvalue())
def my_add(x: int, y: int) -> int:
print('my add called', x, y)
return x + y + 1
# Run in memory
imports = {'py_add': my_add}
native_module = load_obj(obj, imports=imports)
print(dir(native_module))
result = getattr(native_module, 'add')(42, 42)
print(result, '(should be 85)')
