moved crates in lib/ to src/, renamed crates, modified some files' text (#660)

moved crates in lib/ to src/, renamed crates, modified some files' text (#660)

cranelift/codegen/meta-python/semantics/__init__.py

@@ -0,0 +1,77 @@
+"""Definitions for the semantics segment of the Cranelift language."""
+from cdsl.ti import TypeEnv, ti_rtl, get_type_env
+from cdsl.operands import ImmediateKind
+from cdsl.ast import Var
+
+try:
+    from typing import List, Dict, Tuple # noqa
+    from cdsl.ast import VarAtomMap  # noqa
+    from cdsl.xform import XForm, Rtl # noqa
+    from cdsl.ti import VarTyping # noqa
+    from cdsl.instructions import Instruction, InstructionSemantics # noqa
+except ImportError:
+    pass
+
+
+def verify_semantics(inst, src, xforms):
+    # type: (Instruction, Rtl, InstructionSemantics) -> None
+    """
+    Verify that the semantics transforms in xforms correctly describe the
+    instruction described by the src Rtl. This involves checking that:
+        0) src is a single instance of inst
+        1) For all x \\in xforms x.src is a single instance of inst
+        2) For any concrete values V of Literals in inst:
+            For all concrete typing T of inst:
+                Exists single x \\in xforms that applies to src conretazied to
+                V and T
+    """
+    # 0) The source rtl is always a single instance of inst
+    assert len(src.rtl) == 1 and src.rtl[0].expr.inst == inst
+
+    # 1) For all XForms x, x.src is a single instance of inst
+    for x in xforms:
+        assert len(x.src.rtl) == 1 and x.src.rtl[0].expr.inst == inst
+
+    variants = [src]  # type: List[Rtl]
+
+    # 2) For all enumerated immediates, compute all the possible
+    #    versions of src with the concrete value filled in.
+    for i in inst.imm_opnums:
+        op = inst.ins[i]
+        if not (isinstance(op.kind, ImmediateKind) and
+                op.kind.is_enumerable()):
+            continue
+
+        new_variants = []  # type: List[Rtl]
+        for rtl_var in variants:
+            s = {v: v for v in rtl_var.vars()}  # type: VarAtomMap
+            arg = rtl_var.rtl[0].expr.args[i]
+            assert isinstance(arg, Var)
+            for val in op.kind.possible_values():
+                    s[arg] = val
+                    new_variants.append(rtl_var.copy(s))
+        variants = new_variants
+
+    # For any possible version of the src with concrete enumerated immediates
+    for src in variants:
+        # 2) Any possible typing should be covered by exactly ONE semantic
+        # XForm
+        src = src.copy({})
+        typenv = get_type_env(ti_rtl(src, TypeEnv()))
+        typenv.normalize()
+        typenv = typenv.extract()
+
+        for t in typenv.concrete_typings():
+            matching_xforms = []  # type: List[XForm]
+            for x in xforms:
+                if src.substitution(x.src, {}) is None:
+                        continue
+
+                # Translate t using x.symtab
+                t = {x.symtab[str(v)]:  tv for (v, tv) in t.items()}
+                if (x.ti.permits(t)):
+                    matching_xforms.append(x)
+
+            assert len(matching_xforms) == 1,\
+                ("Possible typing {} of {} not matched by exactly one case " +
+                 ": {}").format(t, src.rtl[0], matching_xforms)