use log function for warnings about .mdwn files in pagereader.py

[openpower-isa.git] / src / openpower / decoder / power_insn.py

diff --git a/src/openpower/decoder/power_insn.py b/src/openpower/decoder/power_insn.py
index 79a308b04e79fa3285f62e5d81c69d3702198fcf..6ea7f58d37e5ed5091f4d8cd032f4d8936ff8d9e 100644 (file)
--- a/src/openpower/decoder/power_insn.py
+++ b/src/openpower/decoder/power_insn.py
@@ -770,6 +770,12 @@ class Instruction(_Mapping):
     def __hash__(self):
         return hash(int(self))
 
+    def record(self, db):
+        record = db[self]
+        if record is None:
+            raise KeyError(self)
+        return record
+
     def disassemble(self, db, byteorder="little", verbose=False):
         raise NotImplementedError
 
@@ -790,7 +796,9 @@ class WordInstruction(Instruction):
             bits.append(bit)
         return "".join(map(str, bits))
 
-    def spec(self, record):
+    def spec(self, db):
+        record = self.record(db=db)
+
         immediate = ""
         dynamic_operands = []
         for operand in record.operands.dynamic:
@@ -815,10 +823,12 @@ class WordInstruction(Instruction):
 
         return f"{record.name}{operands}"
 
-    def opcode(self, record):
+    def opcode(self, db):
+        record = self.record(db=db)
         return f"0x{record.opcode.value:08x}"
 
-    def mask(self, record):
+    def mask(self, db):
+        record = self.record(db=db)
         return f"0x{record.opcode.mask:08x}"
 
     def disassemble(self, db, byteorder="little", verbose=False):
@@ -826,7 +836,7 @@ class WordInstruction(Instruction):
         blob = integer.to_bytes(length=4, byteorder=byteorder)
         blob = " ".join(map(lambda byte: f"{byte:02x}", blob))
 
-        record = db[self]
+        record = self.record(db=db)
         if record is None:
             yield f"{blob}    .long 0x{integer:08x}"
             return
@@ -847,9 +857,9 @@ class WordInstruction(Instruction):
         if verbose:
             indent = (" " * 4)
             binary = self.binary
-            spec = self.spec(record=record)
-            opcode = self.opcode(record=record)
-            mask = self.mask(record=record)
+            spec = self.spec(db=db)
+            opcode = self.opcode(db=db)
+            mask = self.mask(db=db)
             yield f"{indent}spec"
             yield f"{indent}{indent}{spec}"
             yield f"{indent}binary"
@@ -1121,34 +1131,23 @@ class SVP64Instruction(PrefixedInstruction):
             bits.append(bit)
         return "".join(map(str, bits))
 
-    def spec(self, record):
-        return f"sv.{self.suffix.spec(record=record)}"
+    def spec(self, db):
+        return f"sv.{self.suffix.spec(db=db)}"
 
-    def opcode(self, record):
-        return self.suffix.opcode(record=record)
+    def opcode(self, db):
+        return self.suffix.opcode(db=db)
 
-    def mask(self, record):
-        return self.suffix.mask(record=record)
+    def mask(self, db):
+        return self.suffix.mask(db=db)
 
-    def disassemble(self, db, byteorder="little", verbose=False):
-        integer_prefix = int(self.prefix)
-        blob_prefix = integer_prefix.to_bytes(length=4, byteorder=byteorder)
-        blob_prefix = " ".join(map(lambda byte: f"{byte:02x}", blob_prefix))
-
-        integer_suffix = int(self.suffix)
-        blob_suffix = integer_suffix.to_bytes(length=4, byteorder=byteorder)
-        blob_suffix = " ".join(map(lambda byte: f"{byte:02x}", blob_suffix))
-
-        record = db[self.suffix]
-        if record is None or record.svp64 is None:
-            yield f"{blob_prefix}    .long 0x{int(self.prefix):08x}"
-            yield f"{blob_suffix}    .long 0x{int(self.suffix):08x}"
-            return
+    def mode(self, db):
+        record = self.record(db=db)
 
         Rc = False
         if record.operands["Rc"] is not None:
             Rc = bool(self[record.fields["Rc"]])
 
+        record = self.record(db=db)
         subvl = self.prefix.rm.subvl
         mode = self.prefix.rm.mode
         sel = mode.sel
@@ -1220,18 +1219,64 @@ class SVP64Instruction(PrefixedInstruction):
                 else:
                     mode = mode.prrc0
 
-        if type(mode) is Mode:
-            raise NotImplementedError
+        modes = {
+            NormalMode.simple: "normal: simple",
+            NormalMode.smr: "normal: smr",
+            NormalMode.pmr: "normal: pmr",
+            NormalMode.svmr: "normal: svmr",
+            NormalMode.pu: "normal: pu",
+            NormalMode.ffrc1: "normal: ffrc1",
+            NormalMode.ffrc0: "normal: ffrc0",
+            NormalMode.sat: "normal: sat",
+            NormalMode.satx: "normal: satx",
+            NormalMode.satpu: "normal: satpu",
+            NormalMode.prrc1: "normal: prrc1",
+            NormalMode.prrc0: "normal: prrc0",
+            LDSTImmMode.simple: "ld/st imm: simple",
+            LDSTImmMode.spu: "ld/st imm: spu",
+            LDSTImmMode.ffrc1: "ld/st imm: ffrc1",
+            LDSTImmMode.ffrc0: "ld/st imm: ffrc0",
+            LDSTImmMode.sat: "ld/st imm: sat",
+            LDSTImmMode.prrc1: "ld/st imm: prrc1",
+            LDSTImmMode.prrc0: "ld/st imm: prrc0",
+            LDSTIdxMode.simple: "ld/st idx simple",
+            LDSTIdxMode.stride: "ld/st idx stride",
+            LDSTIdxMode.sat: "ld/st idx sat",
+            LDSTIdxMode.prrc1: "ld/st idx prrc1",
+            LDSTIdxMode.prrc0: "ld/st idx prrc0",
+        }
+        for (cls, desc) in modes.items():
+            if isinstance(mode, cls):
+                return (mode, desc)
+
+        raise NotImplementedError
+
+    def disassemble(self, db, byteorder="little", verbose=False):
+        integer_prefix = int(self.prefix)
+        blob_prefix = integer_prefix.to_bytes(length=4, byteorder=byteorder)
+        blob_prefix = " ".join(map(lambda byte: f"{byte:02x}", blob_prefix))
+
+        integer_suffix = int(self.suffix)
+        blob_suffix = integer_suffix.to_bytes(length=4, byteorder=byteorder)
+        blob_suffix = " ".join(map(lambda byte: f"{byte:02x}", blob_suffix))
+
+        record = self.record(db=db)
+        if record is None or record.svp64 is None:
+            yield f"{blob_prefix}    .long 0x{int(self.prefix):08x}"
+            yield f"{blob_suffix}    .long 0x{int(self.suffix):08x}"
+            return
 
         yield f"{blob_prefix}    sv.{record.name}"
         yield f"{blob_suffix}"
 
+        (mode, mode_desc) = self.mode(db=db)
+
         if verbose:
             indent = (" " * 4)
             binary = self.binary
-            spec = self.spec(record=record)
-            opcode = self.opcode(record=record)
-            mask = self.mask(record=record)
+            spec = self.spec(db=db)
+            opcode = self.opcode(db=db)
+            mask = self.mask(db=db)
             yield f"{indent}spec"
             yield f"{indent}{indent}{spec}"
             yield f"{indent}binary"
@@ -1254,6 +1299,9 @@ class SVP64Instruction(PrefixedInstruction):
                     record=record, verbose=True)
                 for part in parts:
                     yield f"{indent}{indent}{part}"
+
+            yield f"{indent}mode"
+            yield f"{indent}{indent}{mode_desc}"
             yield ""
 
 
@@ -1426,7 +1474,7 @@ class Database:
 
         mdwndb = MarkdownDatabase()
         fieldsdb = FieldsDatabase()
-        ppcdb = PPCDatabase(root=root, mdwndb=mdwndb, fieldsdb=fieldsdb)
+        ppcdb = PPCDatabase(root=root, mdwndb=mdwndb)
         svp64db = SVP64Database(root=root, ppcdb=ppcdb)
 
         db = set()