def test_glue_with_phi(self):
"""
After replacing the predecessor, the use info of a phi is messed
up.
"""
block1 = self.builder.new_block()
block4 = self.builder.new_block() # This one must be eliminated
block6 = self.builder.new_block()
self.builder.emit(ir.Jump(block1))
self.builder.set_block(block1)
cnst = self.builder.emit(ir.Const(0, 'const', ir.i16))
self.builder.emit(ir.Jump(block4))
self.builder.set_block(block4)
self.builder.emit(ir.Jump(block6))
self.builder.set_block(block6)
phi = self.builder.emit(ir.Phi('res24', ir.i16))
phi.set_incoming(block4, cnst)
cnst2 = self.builder.emit(ir.Const(2, 'cnst2', ir.i16))
binop = self.builder.emit(ir.add(phi, cnst2, 'binop', ir.i16))
phi.set_incoming(block6, binop)
self.builder.emit(ir.Jump(block6))
verify_module(self.module)
# Act:
self.clean_pass.run(self.module)
self.assertNotIn(block4, self.function)
def test_function_tailcall(self):
""" Test if a tailcall in a function works out nicely """
# Prepare an optimizable module:
builder = irutils.Builder()
module = ir.Module('test')
builder.set_module(module)
function = builder.new_function('x', ir.Binding.GLOBAL, ir.i8)
builder.set_function(function)
entry = builder.new_block()
function.entry = entry
a = ir.Parameter('a', ir.i8)
function.add_parameter(a)
b = ir.Parameter('b', ir.i8)
function.add_parameter(b)
builder.set_block(entry)
one = builder.emit(ir.Const(1, 'const', ir.i8))
a2 = builder.emit(ir.add(a, one, 'a2', ir.i8))
b2 = builder.emit(ir.add(b, one, 'b2', ir.i8))
result = builder.emit(ir.FunctionCall(function, [a2, b2], 'rv', ir.i8))
builder.emit(ir.Return(result))
# Verify first version:
module.display()
verify_module(module)
self.assertFalse(function.is_leaf())
# Run optimizer:
self.opt.run(module)
# Verify again:
module.display()
verify_module(module)
self.assertTrue(function.is_leaf())
def expect_ok(self, snippet):
""" Expect a snippet to be OK """
ircode = self.build(snippet)
if len(self.diag.diags) > 0:
self.diag.print_errors()
self.assertTrue(ircode)
verify_module(ircode)
self.assertEqual(0, len(self.diag.diags))
def _do_compile(self, src):
f = io.StringIO(src)
try:
ir_module = self.builder.build(f, None)
except CompilerError as compiler_error:
lines = src.split("\n")
compiler_error.render(lines)
raise
assert isinstance(ir_module, ir.Module)
verify_module(ir_module)
def test_hello(self):
""" Convert C to Ir, and then this IR to C """
src = r"""
void printf(char*);
void main(int b) {
printf("Hello" "world\n");
}
"""
arch = ExampleArch()
builder = CBuilder(arch.info, COptions())
f = io.StringIO(src)
ir_module = builder.build(f, None)
assert isinstance(ir_module, ir.Module)
verify_module(ir_module)
synthesizer = CSynthesizer()
synthesizer.syn_module(ir_module)
def do(self, src, expected_output, lang="c3"):
base_filename = make_filename(self.id())
sample_filename = base_filename + ".py"
list_filename = base_filename + ".html"
bsp_c3 = io.StringIO("""
module bsp;
public function void putc(byte c);
""")
march = "arm"
with html_reporter(list_filename) as reporter:
ir_modules = build_sample_to_ir(src, lang, bsp_c3, march, reporter)
# Test roundtrip of ir_modules
for ir_module in ir_modules:
verify_module(ir_module)
serialization_roundtrip(ir_module)
api.optimize(ir_module,
level=self.opt_level,
reporter=reporter)
with open(sample_filename, "w") as f:
api.ir_to_python(ir_modules, f, reporter=reporter)
# Expose all functions as external symbols:
for ir_module in ir_modules:
for routine in ir_module.functions:
print('_irpy_externals["{0}"] = {0}'.format(
routine.name),
file=f)
# Add glue:
print("", file=f)
print("def bsp_putc(c):", file=f)
print(' print(chr(c), end="")', file=f)
print("", file=f)
# print('_irpy_externals["printf"] = printf', file=f)
print('_irpy_externals["bsp_putc"] = bsp_putc', file=f)
print("", file=f)
print("main_main()", file=f)
print("", file=f)
res = run_python(sample_filename)
self.assertEqual(expected_output, res)
def compile(self, filename):
self.variables = {}
# Prepare the module:
ir_module = ir.Module('toy')
self.io_print2 = ir.ExternalProcedure('io_print2',
[ir.ptr, self.int_type])
ir_module.add_external(self.io_print2)
ir_function = ir.Procedure('toy_toy', ir.Binding.GLOBAL)
ir_module.add_function(ir_function)
self.ir_block = ir.Block('entry')
ir_function.entry = self.ir_block
ir_function.add_block(self.ir_block)
# Load the program:
self.toy_mm.model_from_file('example.tcf')
# Close the procedure:
self.emit(ir.Exit())
verify_module(ir_module)
return ir_module
def puts(txt: str):
pass
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()
{
def tearDown(self):
verify_module(self.module)
