50 lines
1.8 KiB
Python
50 lines
1.8 KiB
Python
"""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, 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:
|
|
1) For all XForms x \in xforms, there is a Var substitution form src to
|
|
x.src
|
|
2) For any possible concrete typing of src there is exactly 1 XForm x
|
|
in xforms that applies.
|
|
"""
|
|
# 0) The source rtl is always a single instruction
|
|
assert len(src.rtl) == 1
|
|
|
|
# 1) For all XForms x, x.src is structurally equivalent to src
|
|
for x in xforms:
|
|
assert src.substitution(x.src, {}) is not None,\
|
|
"XForm {} doesn't describe instruction {}.".format(x, src)
|
|
|
|
# 2) Any possible typing for the instruction 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:
|
|
# 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, inst, matching_xforms)
|