Further fixes to instruction coding

Author: wallento

riscvmodel/code.py

@@ -6,24 +6,27 @@
 from . import __version__
 
 class MachineDecodeError(Exception):
-    pass
+    def __init__(self, word):
+        self.word = word
+    def __str__(self):
+        return "Invalid instruction word: {:08x}".format(self.word)
 
-def decode(machinecode: int):
-    if machinecode & 0x3 != 3:
+def decode(word: int):
+    if word & 0x3 != 3:
         # compact
         for icls in get_insns(cls=InstructionCType):
-            if icls._match(machinecode):
+            if icls._match(word):
                 i = icls()
-                i.decode(machinecode)
+                i.decode(word)
                 return i
-        raise MachineDecodeError("Cannot decode {:04x}".format(machinecode))
-    opcode = machinecode & 0x7F
+        raise MachineDecodeError(word)
+    opcode = word & 0x7F
     for icls in get_insns():
-        if icls._opcode == opcode and icls._match(machinecode):
+        if icls.field_opcode.value == opcode and icls.match(word):
             i = icls()
-            i.decode(machinecode)
+            i.decode(word)
             return i
-    raise MachineDecodeError()
+    raise MachineDecodeError(word)
 
 
 def read_from_binary(fname: str, *, stoponerror: bool = False):

riscvmodel/isa.py

@@ -47,11 +47,19 @@ def asm_signature(cls):
         return signature
 
     @classmethod
-    def extract_field(cls, field, machinecode):
+    def extract_field(cls, field, word):
         fname = "field_{}".format(field)
         base = getattr(cls, fname).base
         size = getattr(cls, fname).size
-        return (machinecode >> base) & (2**size - 1)
+        if not isinstance(base, list):
+            base = [base]
+            size = [size]
+        off = 0
+        value = 0
+        for part in range(len(base)):
+            value |= ((word >> base[part]) & (2**size[part] - 1)) << off
+            off += size[part]
+        return value << getattr(cls, fname).offset
 
     @classmethod
     def set_field(cls, field, word, value):
@@ -61,7 +69,7 @@ def set_field(cls, field, word, value):
         if not isinstance(base, list):
             base = [base]
             size = [size]
-        off = 0
+        off = getattr(cls, fname).offset
         for part in range(len(base)):
             word |= (((value >> off) & (2**size[part] - 1)) << base[part])
             off += size[part]
@@ -82,6 +90,14 @@ def get_isa_format(cls, *, asdict: bool=False):
             fields = [field._asdict() for field in fields]
         return {"id": cls.isa_format_id, "fields": fields}
 
+    @classmethod
+    def match(cls, word: int):
+        """Try to match a machine code to this instruction"""
+        for field in cls.get_static_fields():
+            if cls.extract_field(field.name, word) != field.value:
+                return False
+        return True
+
     def ops_from_string(self, ops: str):
         """
         Extract operands from string
@@ -126,11 +142,13 @@ def decode(self, word: int):
                 assert self.extract_field(field.name, word) == field.value
             else:
                 attr = getattr(self, field.name)
+                value = self.extract_field(field.name, word)
                 if isinstance(attr, Register):
-                    attr.set(self.extract_field(field.name, word))
+                    attr.set(value)
+                elif isinstance(attr, Immediate):
+                    attr.set_from_bits(value)
                 else:
-                    assert isinstance(attr, Immediate)
-                    attr.set_from_bits(self.extract_field(field.name, word))
+                    setattr(self, field.name, value)
 
     def encode(self) -> int:
         """
@@ -661,18 +679,6 @@ class WrappedClass(wrapped):  # pylint: disable=too-few-public-methods
                 assert fid in dir(wrapped), "Invalid field {} for {}".format(fid, wrapped.__name__)
                 setattr(wrapped, fid, getattr(wrapped, fid)._replace(value=kwargs[field]))
 
-            @classmethod
-            def match(cls, word: int):
-                """Try to match a machine code to this instruction"""
-                if not cls.field_opcode:
-                    return False
-
-                for field in cls.get_static_fields():
-                    if cls.extract_field(field.name, word) != field.value:
-                        return False
-
-                return True
-
         WrappedClass.__name__ = wrapped.__name__
         WrappedClass.__module__ = wrapped.__module__
         WrappedClass.__qualname__ = wrapped.__qualname__
@@ -701,8 +707,6 @@ def wrapper(wrapped):
         class WrappedClass(wrapped):  # pylint: disable=too-few-public-methods
             """Generic wrapper class"""
 
-            #TODO
-
         WrappedClass.__name__ = wrapped.__name__
         WrappedClass.__module__ = wrapped.__module__
         WrappedClass.__qualname__ = wrapped.__qualname__

riscvmodel/sim.py

@@ -26,7 +26,7 @@ def run(self, *, pc=0):
       except TerminateException as exc:
         assert exc.returncode == 0
         return cnt
-      except IndexError:
+      except IndexError as exc:
         return cnt
     return cnt