Implement a value-simplifying optimization for the CFG JIT

kernel/modelverse_jit/cfg_ir.py

@@ -121,7 +121,10 @@ class Definition(object):
     def get_all_dependencies(self):
         """Gets all definitions and instructions on which this definition depends,
            along with any dependencies of instruction dependencies."""
-        return self.value.get_all_dependencies()
+        if isinstance(self.value, Definition):
+            return [self.value]
+        else:
+            return self.value.get_all_dependencies()
 
     def has_side_effects(self):
         """Tests if this definition produces any side-effects."""

kernel/modelverse_jit/cfg_optimization.py

@@ -309,6 +309,23 @@ def optimize_calls(entry_point, jit):
         for exists_def in global_exists_defs[resolve_global]:
             exists_def.redefine(cfg_ir.Literal(False))
 
+def simplify_values(entry_point):
+    """Simplifies values in the control-flow graph defined by the given entry point."""
+    for block in get_all_blocks(entry_point):
+        for definition in block.definitions:
+            def_val = cfg_ir.get_def_value(definition)
+            if isinstance(def_val, cfg_ir.Read):
+                read_node = cfg_ir.get_def_value(def_val.node)
+                if isinstance(read_node, cfg_ir.CreateNode):
+                    definition.redefine(read_node.value)
+            elif isinstance(def_val, cfg_ir.Binary):
+                lhs = cfg_ir.get_def_value(def_val.lhs)
+                rhs = cfg_ir.get_def_value(def_val.rhs)
+                if isinstance(lhs, cfg_ir.Literal) and isinstance(rhs, cfg_ir.Literal):
+                    definition.redefine(
+                        cfg_ir.Literal(
+                            eval('%r %s %r' % (lhs.literal, def_val.operator, rhs.literal))))
+
 def optimize(entry_point, jit):
     """Optimizes the control-flow graph defined by the given entry point."""
     optimize_graph_flow(entry_point)
@@ -316,6 +333,7 @@ def optimize(entry_point, jit):
     optimize_graph_flow(entry_point)
     eliminate_trivial_phis(entry_point)
     optimize_calls(entry_point, jit)
+    simplify_values(entry_point)
     eliminate_unused_definitions(entry_point)
     optimize_graph_flow(entry_point)
     merge_blocks(entry_point)