[mypyc] Simplify generated C by omitting gotos to the next block (#10230)

This reduces the number of lines in the generated C when compiling
the richards benchmark by about 5%.

The main benefit is making the generated C easier to read by humans.

This may also marginally improve the speed of compilation.

Author: JukkaL

mypyc/codegen/emitfunc.py

@@ -1,6 +1,6 @@
 """Code generation for native function bodies."""
 
-from typing import Union
+from typing import Union, Optional
 from typing_extensions import Final
 
 from mypyc.common import (
@@ -73,11 +73,17 @@ def generate_native_function(fn: FuncIR,
                                                                      init=init))
 
     # Before we emit the blocks, give them all labels
-    for i, block in enumerate(fn.blocks):
+    blocks = fn.blocks
+    for i, block in enumerate(blocks):
         block.label = i
 
-    for block in fn.blocks:
+    for i in range(len(blocks)):
+        block = blocks[i]
+        next_block = None
+        if i + 1 < len(blocks):
+            next_block = blocks[i + 1]
         body.emit_label(block)
+        visitor.next_block = next_block
         for op in block.ops:
             op.accept(visitor)
 
@@ -99,23 +105,31 @@ def __init__(self,
         self.source_path = source_path
         self.module_name = module_name
         self.literals = emitter.context.literals
+        self.next_block = None  # type: Optional[BasicBlock]
 
     def temp_name(self) -> str:
         return self.emitter.temp_name()
 
     def visit_goto(self, op: Goto) -> None:
-        self.emit_line('goto %s;' % self.label(op.label))
+        if op.label is not self.next_block:
+            self.emit_line('goto %s;' % self.label(op.label))
 
     def visit_branch(self, op: Branch) -> None:
-        neg = '!' if op.negated else ''
-
+        true, false = op.true, op.false
+        negated = op.negated
+        if true is self.next_block and op.traceback_entry is None:
+            # Switch true/false since it avoids an else block.
+            true, false = false, true
+            negated = not negated
+
+        neg = '!' if negated else ''
         cond = ''
         if op.op == Branch.BOOL:
             expr_result = self.reg(op.value)
             cond = '{}{}'.format(neg, expr_result)
         elif op.op == Branch.IS_ERROR:
             typ = op.value.type
-            compare = '!=' if op.negated else '=='
+            compare = '!=' if negated else '=='
             if isinstance(typ, RTuple):
                 # TODO: What about empty tuple?
                 cond = self.emitter.tuple_undefined_check_cond(typ,
@@ -133,15 +147,24 @@ def visit_branch(self, op: Branch) -> None:
         if op.traceback_entry is not None or op.rare:
             cond = 'unlikely({})'.format(cond)
 
-        self.emit_line('if ({}) {{'.format(cond))
-
-        self.emit_traceback(op)
-
-        self.emit_lines(
-            'goto %s;' % self.label(op.true),
-            '} else',
-            '    goto %s;' % self.label(op.false)
-        )
+        if false is self.next_block:
+            if op.traceback_entry is None:
+                self.emit_line('if ({}) goto {};'.format(cond, self.label(true)))
+            else:
+                self.emit_line('if ({}) {{'.format(cond))
+                self.emit_traceback(op)
+                self.emit_lines(
+                    'goto %s;' % self.label(true),
+                    '}'
+                )
+        else:
+            self.emit_line('if ({}) {{'.format(cond))
+            self.emit_traceback(op)
+            self.emit_lines(
+                'goto %s;' % self.label(true),
+                '} else',
+                '    goto %s;' % self.label(false)
+            )
 
     def visit_return(self, op: Return) -> None:
         value_str = self.reg(op.value)

mypyc/test/test_emitfunc.py

@@ -1,6 +1,6 @@
 import unittest
 
-from typing import List
+from typing import List, Optional
 
 from mypy.ordered_dict import OrderedDict
 
@@ -24,9 +24,7 @@
 from mypyc.codegen.emitfunc import generate_native_function, FunctionEmitterVisitor
 from mypyc.primitives.registry import binary_ops
 from mypyc.primitives.misc_ops import none_object_op
-from mypyc.primitives.list_ops import (
-    list_get_item_op, list_set_item_op, list_append_op
-)
+from mypyc.primitives.list_ops import list_get_item_op, list_set_item_op, list_append_op
 from mypyc.primitives.dict_ops import (
     dict_new_op, dict_update_op, dict_get_item_op, dict_set_item_op
 )
@@ -36,6 +34,8 @@
 
 
 class TestFunctionEmitterVisitor(unittest.TestCase):
+    """Test generation of fragments of C from individual IR ops."""
+
     def setUp(self) -> None:
         self.registers = []  # type: List[Register]
 
@@ -75,6 +75,10 @@ def test_goto(self) -> None:
         self.assert_emit(Goto(BasicBlock(2)),
                          "goto CPyL2;")
 
+    def test_goto_next_block(self) -> None:
+        next_block = BasicBlock(2)
+        self.assert_emit(Goto(next_block), "", next_block=next_block)
+
     def test_return(self) -> None:
         self.assert_emit(Return(self.m),
                          "return cpy_r_m;")
@@ -128,6 +132,61 @@ def test_branch(self) -> None:
                                 goto CPyL9;
                          """)
 
+    def test_branch_no_else(self) -> None:
+        next_block = BasicBlock(9)
+        b = Branch(self.b, BasicBlock(8), next_block, Branch.BOOL)
+        self.assert_emit(b,
+                         """if (cpy_r_b) goto CPyL8;""",
+                         next_block=next_block)
+        next_block = BasicBlock(9)
+        b = Branch(self.b, BasicBlock(8), next_block, Branch.BOOL)
+        b.negated = True
+        self.assert_emit(b,
+                         """if (!cpy_r_b) goto CPyL8;""",
+                         next_block=next_block)
+
+    def test_branch_no_else_negated(self) -> None:
+        next_block = BasicBlock(1)
+        b = Branch(self.b, next_block, BasicBlock(2), Branch.BOOL)
+        self.assert_emit(b,
+                         """if (!cpy_r_b) goto CPyL2;""",
+                         next_block=next_block)
+        next_block = BasicBlock(1)
+        b = Branch(self.b, next_block, BasicBlock(2), Branch.BOOL)
+        b.negated = True
+        self.assert_emit(b,
+                         """if (cpy_r_b) goto CPyL2;""",
+                         next_block=next_block)
+
+    def test_branch_is_error(self) -> None:
+        b = Branch(self.b, BasicBlock(8), BasicBlock(9), Branch.IS_ERROR)
+        self.assert_emit(b,
+                         """if (cpy_r_b == 2) {
+                                goto CPyL8;
+                            } else
+                                goto CPyL9;
+                         """)
+        b = Branch(self.b, BasicBlock(8), BasicBlock(9), Branch.IS_ERROR)
+        b.negated = True
+        self.assert_emit(b,
+                         """if (cpy_r_b != 2) {
+                                goto CPyL8;
+                            } else
+                                goto CPyL9;
+                         """)
+
+    def test_branch_is_error_next_block(self) -> None:
+        next_block = BasicBlock(8)
+        b = Branch(self.b, next_block, BasicBlock(9), Branch.IS_ERROR)
+        self.assert_emit(b,
+                         """if (cpy_r_b != 2) goto CPyL9;""",
+                         next_block=next_block)
+        b = Branch(self.b, next_block, BasicBlock(9), Branch.IS_ERROR)
+        b.negated = True
+        self.assert_emit(b,
+                         """if (cpy_r_b == 2) goto CPyL9;""",
+                         next_block=next_block)
+
     def test_call(self) -> None:
         decl = FuncDecl('myfn', None, 'mod',
                         FuncSignature([RuntimeArg('m', int_rprimitive)], int_rprimitive))
@@ -318,7 +377,7 @@ def test_long_unsigned(self) -> None:
         self.assert_emit(Assign(a, Integer((1 << 31) - 1, int64_rprimitive)),
                          """cpy_r_a = 2147483647;""")
 
-    def assert_emit(self, op: Op, expected: str) -> None:
+    def assert_emit(self, op: Op, expected: str, next_block: Optional[BasicBlock] = None) -> None:
         block = BasicBlock(0)
         block.ops.append(op)
         value_names = generate_names_for_ir(self.registers, [block])
@@ -328,13 +387,17 @@ def assert_emit(self, op: Op, expected: str) -> None:
         declarations.fragments = []
 
         visitor = FunctionEmitterVisitor(emitter, declarations, 'prog.py', 'prog')
+        visitor.next_block = next_block
 
         op.accept(visitor)
         frags = declarations.fragments + emitter.fragments
         actual_lines = [line.strip(' ') for line in frags]
         assert all(line.endswith('\n') for line in actual_lines)
         actual_lines = [line.rstrip('\n') for line in actual_lines]
-        expected_lines = expected.rstrip().split('\n')
+        if not expected.strip():
+            expected_lines = []
+        else:
+            expected_lines = expected.rstrip().split('\n')
         expected_lines = [line.strip(' ') for line in expected_lines]
         assert_string_arrays_equal(expected_lines, actual_lines,
                                    msg='Generated code unexpected')