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)