sort out sv.cmp zz (and correct unit tests)

[openpower-isa.git] / src / openpower / sv / sv_binutils_fptrans.py

diff --git a/src/openpower/sv/sv_binutils_fptrans.py b/src/openpower/sv/sv_binutils_fptrans.py
index d6aec3afe82cc416c50a3dd77de860fc103b43ee..cbe59b8e1085a89a649189002282a0ec0f95fa5a 100644 (file)
--- a/src/openpower/sv/sv_binutils_fptrans.py
+++ b/src/openpower/sv/sv_binutils_fptrans.py
@@ -15,54 +15,6 @@ from openpower.decoder.power_insn import (
 )
 
 
-@_dataclasses.dataclass(eq=True, frozen=True)
-class StaticOperand:
-    name: str
-    value: int
-    span: tuple
-
-
-@_dataclasses.dataclass(eq=True, frozen=True)
-class DynamicOperand:
-    name: str
-    span: tuple
-
-
-@_functools.total_ordering
-@_dataclasses.dataclass(eq=True, frozen=True)
-class Entry:
-    name: str
-    static_operands: tuple
-    dynamic_operands: tuple
-
-    def __lt__(self, other):
-        if not isinstance(other, self.__class__):
-            return NotImplemented
-        return ((self.PO, self.XO, self.Rc) <
-            (other.PO, other.XO, other.Rc))
-
-    @property
-    def PO(self):
-        for operand in self.static_operands:
-            if operand.name == "PO":
-                return operand.value
-        raise ValueError(self)
-
-    @property
-    def XO(self):
-        for operand in self.static_operands:
-            if operand.name == "XO":
-                return operand.value
-        raise ValueError(self)
-
-    @property
-    def Rc(self):
-        for operand in self.static_operands:
-            if operand.name == "Rc":
-                return operand.value
-        raise ValueError(self)
-
-
 def collect(db):
     fptrans = tuple(_FPTRANS_INSNS)
     fptrans_Rc = tuple(map(lambda name: f"{name}.", fptrans))
@@ -73,51 +25,8 @@ def collect(db):
     for record in filter(fptrans_match, db):
         if len(record.opcodes) > 1:
             raise NotImplementedError(record.opcodes)
-        PO = record.section.opcode
-        if PO is None:
-            PO = tuple(record.ppc)[0].opcode
-            XO = None
-        else:
-            XO = tuple(record.ppc)[0].opcode
-
-        @_dataclasses.dataclass(eq=True, frozen=True)
-        class POStaticOperand(_StaticOperand):
-            def __init__(self, PO):
-                value = (PO.value & PO.mask)
-                return super().__init__(name="PO", value=value)
-
-            def span(self, record):
-                return tuple(range(0, 6))
-
-        @_dataclasses.dataclass(eq=True, frozen=True)
-        class XOStaticOperand(_StaticOperand):
-            def __init__(self, XO):
-                value = (XO.value & XO.mask)
-                return super().__init__(name="XO", value=value)
-
-            def span(self, record):
-                return tuple(record.section.bitsel)
-
-        static_operands = [POStaticOperand(PO=PO)]
-        if XO is not None:
-            static_operands.append(XOStaticOperand(XO=XO))
-        static_operands.extend(record.mdwn.operands.static)
-        dynamic_operands = record.mdwn.operands.dynamic
-
-        def static_operand(operand):
-            return StaticOperand(name=operand.name,
-                value=operand.value, span=operand.span(record=record))
-
-        def dynamic_operand(operand):
-            return DynamicOperand(name=operand.name,
-                span=operand.span(record=record))
-
-        static_operands = tuple(map(static_operand, static_operands))
-        dynamic_operands = tuple(map(dynamic_operand, dynamic_operands))
 
-        yield Entry(name=record.name,
-            static_operands=static_operands,
-            dynamic_operands=dynamic_operands)
+        yield record
 
 
 def opcodes(entry):
@@ -134,8 +43,8 @@ def opcodes(entry):
     return f"{{{string}}},"
 
 
-def asm(entry, binutils=False, regex=False):
-    operands = tuple(entry.dynamic_operands)
+def asm(record, binutils=False, regex=False):
+    operands = tuple(record.dynamic_operands)
     for (idx, operand) in enumerate(operands):
         values = []
         for each in operands:
@@ -152,20 +61,19 @@ def asm(entry, binutils=False, regex=False):
             value = f"r{value}"
         values[idx] = value
         sep = "\s+" if regex else " "
-        yield f"{entry.name}{sep}{','.join(values)}"
+        yield f"{record.name}{sep}{','.join(values)}"
 
 
-def dis(entry, binutils=True):
+def dis(record, binutils=True):
     def objdump(byte):
         return f"{byte:02x}"
 
-    asm_plain = tuple(asm(entry, binutils=binutils, regex=False))
-    asm_regex = tuple(asm(entry, binutils=binutils, regex=True))
-    for (idx, dynamic_operand) in enumerate(entry.dynamic_operands):
+    asm_plain = tuple(asm(record, binutils=binutils, regex=False))
+    asm_regex = tuple(asm(record, binutils=binutils, regex=True))
+    for (idx, dynamic_operand) in enumerate(record.dynamic_operands):
         insn = _WordInstruction.integer(value=0)
-        for static_operand in entry.static_operands:
-            span = static_operand.span
-            insn[span] = static_operand.value
+        for static_operand in record.static_operands:
+            insn[static_operand.span] = static_operand.value
         span = dynamic_operand.span
         insn[span] = ((1 << len(span)) - 1)
         if binutils: