Move formats, entities, and immediates to the base package.

- base.formats defines instruction formats.
- base.entities defines kinds of entity references.
- base.immediates defines kinds of imediate operands.

lib/cretonne/meta/base/entities.py

@@ -0,0 +1,29 @@
+"""
+The `cretonne.entities` module predefines all the Cretonne entity reference
+operand types. There are corresponding definitions in the `cretonne.entities`
+Rust module.
+"""
+from __future__ import absolute_import
+from cdsl.operands import EntityRefKind
+
+
+#: A reference to an extended basic block in the same function.
+#: This is primarliy used in control flow instructions.
+ebb = EntityRefKind(
+        'ebb', 'An extended basic block in the same function.',
+        default_member='destination')
+
+#: A reference to a stack slot declared in the function preamble.
+stack_slot = EntityRefKind('stack_slot', 'A stack slot.')
+
+#: A reference to a function sugnature declared in the function preamble.
+#: Tbis is used to provide the call signature in an indirect call instruction.
+sig_ref = EntityRefKind('sig_ref', 'A function signature.')
+
+#: A reference to an external function declared in the function preamble.
+#: This is used to provide the callee and signature in a call instruction.
+func_ref = EntityRefKind('func_ref', 'An external function.')
+
+#: A reference to a jump table declared in the function preamble.
+jump_table = EntityRefKind(
+        'jump_table', 'A jump table.', default_member='table')

lib/cretonne/meta/base/formats.py

@@ -0,0 +1,58 @@
+"""
+The cretonne.formats defines all instruction formats.
+
+Every instruction format has a corresponding `InstructionData` variant in the
+Rust representation of cretonne IL, so all instruction formats must be defined
+in this module.
+"""
+from __future__ import absolute_import
+from cdsl.operands import VALUE, VARIABLE_ARGS
+from cretonne import InstructionFormat
+from .immediates import imm64, uimm8, ieee32, ieee64, immvector, intcc, floatcc
+from .entities import ebb, sig_ref, func_ref, jump_table
+
+Nullary = InstructionFormat()
+
+Unary = InstructionFormat(VALUE)
+UnaryImm = InstructionFormat(imm64)
+UnaryIeee32 = InstructionFormat(ieee32)
+UnaryIeee64 = InstructionFormat(ieee64)
+UnaryImmVector = InstructionFormat(immvector, boxed_storage=True)
+UnarySplit = InstructionFormat(VALUE, multiple_results=True)
+
+Binary = InstructionFormat(VALUE, VALUE)
+BinaryImm = InstructionFormat(VALUE, imm64)
+BinaryImmRev = InstructionFormat(imm64, VALUE)
+
+# Generate result + overflow flag.
+BinaryOverflow = InstructionFormat(VALUE, VALUE, multiple_results=True)
+
+# The select instructions are controlled by the second VALUE operand.
+# The first VALUE operand is the controlling flag which has a derived type.
+# The fma instruction has the same constraint on all inputs.
+Ternary = InstructionFormat(VALUE, VALUE, VALUE, typevar_operand=1)
+
+# Carry in *and* carry out for `iadd_carry` and friends.
+TernaryOverflow = InstructionFormat(
+        VALUE, VALUE, VALUE, multiple_results=True, boxed_storage=True)
+
+InsertLane = InstructionFormat(VALUE, ('lane', uimm8), VALUE)
+ExtractLane = InstructionFormat(VALUE, ('lane', uimm8))
+
+IntCompare = InstructionFormat(intcc, VALUE, VALUE)
+FloatCompare = InstructionFormat(floatcc, VALUE, VALUE)
+
+Jump = InstructionFormat(ebb, VARIABLE_ARGS, boxed_storage=True)
+Branch = InstructionFormat(VALUE, ebb, VARIABLE_ARGS, boxed_storage=True)
+BranchTable = InstructionFormat(VALUE, jump_table)
+
+Call = InstructionFormat(
+        func_ref, VARIABLE_ARGS, multiple_results=True, boxed_storage=True)
+IndirectCall = InstructionFormat(
+        sig_ref, VALUE, VARIABLE_ARGS,
+        multiple_results=True, boxed_storage=True)
+Return = InstructionFormat(VARIABLE_ARGS, boxed_storage=True)
+
+
+# Finally extract the names of global variables in this module.
+InstructionFormat.extract_names(globals())

lib/cretonne/meta/base/immediates.py

@@ -0,0 +1,52 @@
+"""
+The `cretonne.immediates` module predefines all the Cretonne immediate operand
+types.
+"""
+from __future__ import absolute_import
+from cdsl.operands import ImmediateKind
+
+#: A 64-bit immediate integer operand.
+#:
+#: This type of immediate integer can interact with SSA values with any
+#: :py:class:`cretonne.IntType` type.
+imm64 = ImmediateKind('imm64', 'A 64-bit immediate integer.')
+
+#: An unsigned 8-bit immediate integer operand.
+#:
+#: This small operand is used to indicate lane indexes in SIMD vectors and
+#: immediate bit counts on shift instructions.
+uimm8 = ImmediateKind('uimm8', 'An 8-bit immediate unsigned integer.')
+
+#: A 32-bit immediate floating point operand.
+#:
+#: IEEE 754-2008 binary32 interchange format.
+ieee32 = ImmediateKind('ieee32', 'A 32-bit immediate floating point number.')
+
+#: A 64-bit immediate floating point operand.
+#:
+#: IEEE 754-2008 binary64 interchange format.
+ieee64 = ImmediateKind('ieee64', 'A 64-bit immediate floating point number.')
+
+#: A large SIMD vector constant.
+immvector = ImmediateKind(
+        'immvector',
+        'An immediate SIMD vector.',
+        rust_type='ImmVector')
+
+#: A condition code for comparing integer values.
+#:
+#: This enumerated operand kind is used for the :cton:inst:`icmp` instruction
+#: and corresponds to the `condcodes::IntCC` Rust type.
+intcc = ImmediateKind(
+        'intcc',
+        'An integer comparison condition code.',
+        default_member='cond', rust_type='IntCC')
+
+#: A condition code for comparing floating point values.
+#:
+#: This enumerated operand kind is used for the :cton:inst:`fcmp` instruction
+#: and corresponds to the `condcodes::FloatCC` Rust type.
+floatcc = ImmediateKind(
+        'floatcc',
+        'A floating point comparison condition code.',
+        default_member='cond', rust_type='FloatCC')