Rename the 'cretonne' crate to 'cretonne-codegen'.

This fixes the next part of #287.
2018-04-17 08:48:02 -07:00
parent 7767186dd0
commit 24fa169e1f
254 changed files with 265 additions and 264 deletions
--- a/lib/codegen/meta/semantics/primitives.py
+++ b/lib/codegen/meta/semantics/primitives.py
@@ -0,0 +1,133 @@
+"""
+Cretonne primitive instruction set.
+
+This module defines a primitive instruction set, in terms of which the base set
+is described. Most instructions in this set correspond 1-1 with an SMTLIB
+bitvector function.
+"""
+from __future__ import absolute_import
+from cdsl.operands import Operand
+from cdsl.typevar import TypeVar
+from cdsl.instructions import Instruction, InstructionGroup
+from cdsl.ti import WiderOrEq
+from base.types import b1
+from base.immediates import imm64
+import base.formats # noqa
+
+GROUP = InstructionGroup("primitive", "Primitive instruction set")
+
+BV = TypeVar('BV', 'A bitvector type.', bitvecs=True)
+BV1 = TypeVar('BV1', 'A single bit bitvector.', bitvecs=(1, 1))
+Real = TypeVar('Real', 'Any real type.', ints=True, floats=True,
+               bools=True, simd=True)
+
+x = Operand('x', BV, doc="A semantic value X")
+y = Operand('x', BV, doc="A semantic value Y (same width as X)")
+a = Operand('a', BV, doc="A semantic value A (same width as X)")
+cond = Operand('b', TypeVar.singleton(b1), doc='A b1 value')
+
+real = Operand('real', Real, doc="A real cretonne value")
+fromReal = Operand('fromReal', Real.to_bitvec(),
+                   doc="A real cretonne value converted to a BV")
+
+#
+# BV Conversion/Materialization
+#
+prim_to_bv = Instruction(
+        'prim_to_bv', r"""
+        Convert an SSA Value to a flat bitvector
+        """,
+        ins=(real), outs=(fromReal))
+
+prim_from_bv = Instruction(
+        'prim_from_bv', r"""
+        Convert a flat bitvector to a real SSA Value.
+        """,
+        ins=(fromReal), outs=(real))
+
+N = Operand('N', imm64)
+bv_from_imm64 = Instruction(
+        'bv_from_imm64', r"""Materialize an imm64 as a bitvector.""",
+        ins=(N), outs=a)
+
+#
+# Generics
+#
+bvite = Instruction(
+        'bvite', r"""Bitvector ternary operator""",
+        ins=(cond, x, y), outs=a)
+
+
+xh = Operand('xh', BV.half_width(),
+             doc="A semantic value representing the upper half of X")
+xl = Operand('xl', BV.half_width(),
+             doc="A semantic value representing the lower half of X")
+bvsplit = Instruction(
+        'bvsplit', r"""
+        """,
+        ins=(x), outs=(xh, xl))
+
+xy = Operand('xy', BV.double_width(),
+             doc="A semantic value representing the concatenation of X and Y")
+bvconcat = Instruction(
+        'bvconcat', r"""
+        """,
+        ins=(x, y), outs=xy)
+
+bvadd = Instruction(
+        'bvadd', r"""
+        Standard 2's complement addition. Equivalent to wrapping integer
+        addition: :math:`a := x + y \pmod{2^B}`.
+
+        This instruction does not depend on the signed/unsigned interpretation
+        of the operands.
+        """,
+        ins=(x, y), outs=a)
+#
+# Bitvector comparisons
+#
+
+bveq = Instruction(
+        'bveq', r"""Unsigned bitvector equality""",
+        ins=(x, y), outs=cond)
+bvne = Instruction(
+        'bveq', r"""Unsigned bitvector inequality""",
+        ins=(x, y), outs=cond)
+bvsge = Instruction(
+        'bvsge', r"""Signed bitvector greater or equal""",
+        ins=(x, y), outs=cond)
+bvsgt = Instruction(
+        'bvsgt', r"""Signed bitvector greater than""",
+        ins=(x, y), outs=cond)
+bvsle = Instruction(
+        'bvsle', r"""Signed bitvector less than or equal""",
+        ins=(x, y), outs=cond)
+bvslt = Instruction(
+        'bvslt', r"""Signed bitvector less than""",
+        ins=(x, y), outs=cond)
+bvuge = Instruction(
+        'bvuge', r"""Unsigned bitvector greater or equal""",
+        ins=(x, y), outs=cond)
+bvugt = Instruction(
+        'bvugt', r"""Unsigned bitvector greater than""",
+        ins=(x, y), outs=cond)
+bvule = Instruction(
+        'bvule', r"""Unsigned bitvector less than or equal""",
+        ins=(x, y), outs=cond)
+bvult = Instruction(
+        'bvult', r"""Unsigned bitvector less than""",
+        ins=(x, y), outs=cond)
+
+# Extensions
+ToBV = TypeVar('ToBV', 'A bitvector type.', bitvecs=True)
+x1 = Operand('x1', ToBV, doc="")
+
+bvzeroext = Instruction(
+        'bvzeroext', r"""Unsigned bitvector extension""",
+        ins=x, outs=x1, constraints=WiderOrEq(ToBV, BV))
+
+bvsignext = Instruction(
+        'bvsignext', r"""Signed bitvector extension""",
+        ins=x, outs=x1, constraints=WiderOrEq(ToBV, BV))
+
+GROUP.close()