Add insturction semantics. Add semantics for vsplit,vconcat,iadd. Add initial tests

lib/cretonne/meta/semantics/__init__.py

@@ -0,0 +1,55 @@
+"""Definitions for the semantics segment of the Cretonne language."""
+from cdsl.ti import TypeEnv, ti_rtl, get_type_env
+
+try:
+    from typing import List, Dict, Tuple # noqa
+    from cdsl.ast import Var # noqa
+    from cdsl.xform import XForm # noqa
+    from cdsl.ti import VarTyping # noqa
+    from cdsl.instructions import Instruction, InstructionSemantics # noqa
+except ImportError:
+    pass
+
+
+def verify_semantics(inst, sem):
+    # type: (Instruction, InstructionSemantics) -> None
+    """
+    Verify that the semantics sem correctly describes the instruction inst.
+    This involves checking that:
+        1) For all XForms x \in sem, x.src consists of a single instance of
+           inst
+        2) For any possible concrete typing of inst there is exactly 1 XForm x
+           in sem that applies.
+    """
+    # 1) The source rtl is always a single instance of inst.
+    for xform in sem:
+        assert len(xform.src.rtl) == 1 and\
+            xform.src.rtl[0].expr.inst == inst,\
+            "XForm {} doesn't describe instruction {}."\
+            .format(xform, inst)
+
+    # 2) Any possible typing for the instruction should be covered by
+    #    exactly ONE semantic XForm
+    inst_rtl = sem[0].src
+    typenv = get_type_env(ti_rtl(inst_rtl, TypeEnv()))
+
+    # This bit is awkward. Concrete typing is defined in terms of the vars
+    # of one Rtl. We arbitrarily picked that Rtl to be sem[0].src. For any
+    # other XForms in sem, we must build a substitution form
+    # sem[0].src->sem[N].src, before we can check if sem[N] permits one of
+    # the concrete typings of our Rtl.
+    # TODO: Can this be made cleaner?
+    subst = [inst_rtl.substitution(x.src, {}) for x in sem]
+    assert not any(x is None for x in subst)
+    sub_sem = list(zip(subst, sem))  # type: List[Tuple[Dict[Var, Var], XForm]] # noqa
+
+    def subst_typing(typing, sub):
+        # type: (VarTyping, Dict[Var, Var]) -> VarTyping
+        return {sub[v]: tv for (v, tv) in typing.items()}
+
+    for t in typenv.concrete_typings():
+        matching_xforms = [x for (s, x) in sub_sem
+                           if x.ti.permits(subst_typing(t, s))]
+        assert len(matching_xforms) == 1,\
+            ("Possible typing {} of {} not matched by exactly one case " +
+             ": {}").format(t, inst, matching_xforms)