smallworld-re 1.0.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

smallworld/emulators/ghidra/machdefs/machdef.py

@@ -0,0 +1,81 @@
+import abc
+import typing
+
+from ghidra.app.plugin.processors.sleigh import SleighLanguageProvider
+from ghidra.program.model.lang import Language, LanguageID, Register
+
+from .... import exceptions, platforms, utils
+
+
+class GhidraMachineDef:
+    """Container class for ghdra architecture-specific definitions"""
+
+    @property
+    @abc.abstractmethod
+    def arch(self) -> platforms.Architecture:
+        """The architecture ID"""
+        raise NotImplementedError("This is an abstract method")
+
+    @property
+    @abc.abstractmethod
+    def byteorder(self) -> platforms.Byteorder:
+        """The byte order"""
+        raise NotImplementedError("This is an abstract method")
+
+    @property
+    @abc.abstractmethod
+    def language_id(self) -> str:
+        """The Pcode language ID"""
+        raise NotImplementedError("This is an abstract method")
+
+    # Does Pcode support single-instruction stepping for this ISA.
+    #
+    # Instructions with delay slots can't be lifted into Pcode
+    # without also lifting the instruction in the delay slot.
+    #
+    # This flag indicates that this machine uses such instructions,
+    # and is not safe to step in this manner
+    supports_single_step: bool = True
+
+    _registers: typing.Dict[str, typing.Optional[str]]
+
+    def __init__(self):
+        # Load the Pcode language definition
+        slp = SleighLanguageProvider.getSleighLanguageProvider()
+        langID = LanguageID(self.language_id)
+        self.language: Language = slp.getLanguage(langID)
+        assert self.language is not None
+
+    def pcode_reg(self, name: str) -> Register:
+        if name not in self._registers:
+            raise KeyError(f"Unknown register for {self.arch}:{self.byteorder}: {name}")
+        if self._registers[name] is None:
+            raise exceptions.UnsupportedRegisterError(
+                f"Register {name} not recognized by pcode for {self.arch}:{self.byteorder}"
+            )
+        reg = self.language.getRegister(self._registers[name])
+        assert reg is not None, name
+        return reg
+
+    @classmethod
+    def for_platform(cls, platform: platforms.Platform):
+        """Find the appropriate MachineDef for your architecture
+
+        Arguments:
+            arch: The architecture ID you want
+            byteorder: The byteorderness you want
+
+        Returns:
+            An instance of the appropriate MachineDef
+
+        Raises:
+            ValueError: If no MachineDef subclass matches your request
+        """
+        try:
+            return utils.find_subclass(
+                cls,
+                lambda x: x.arch == platform.architecture
+                and x.byteorder == platform.byteorder,
+            )
+        except:
+            raise ValueError(f"No machine model for {platform}")

smallworld/emulators/ghidra/machdefs/mips.py

@@ -0,0 +1,163 @@
+from ....platforms import Architecture, Byteorder
+from .machdef import GhidraMachineDef
+
+
+class MIPSMachineDef(GhidraMachineDef):
+    arch = Architecture.MIPS32
+
+    # NOTE: MIPS registers have a name and a number
+    # angr's machine state doesn't use the number,
+    # so... name.
+    _registers = {
+        # *** General-Purpose Registers ***
+        # Assembler-Temporary Register
+        "at": "at",
+        "1": "at",
+        # Return Value Registers
+        "v0": "v0",
+        "2": "v0",
+        "v1": "v1",
+        "3": "v1",
+        # Argument Registers
+        "a0": "a0",
+        "4": "a0",
+        "a1": "a1",
+        "5": "a1",
+        "a2": "a2",
+        "6": "a2",
+        "a3": "a3",
+        "7": "a3",
+        # Temporary Registers
+        "t0": "t0",
+        "8": "t0",
+        "t1": "t1",
+        "9": "t1",
+        "t2": "t2",
+        "10": "t2",
+        "t3": "t3",
+        "11": "t3",
+        "t4": "t4",
+        "12": "t4",
+        "t5": "t5",
+        "13": "t5",
+        "t6": "t6",
+        "14": "t6",
+        "t7": "t7",
+        "15": "t7",
+        # NOTE: These numbers aren't out of order.
+        # t8 and t9 are later in the register file than t0 - t7.
+        "t8": "t8",
+        "24": "t8",
+        "t9": "t9",
+        "25": "t9",
+        # Saved Registers
+        "s0": "s0",
+        "16": "s0",
+        "s1": "s1",
+        "17": "s1",
+        "s2": "s2",
+        "18": "s2",
+        "s3": "s3",
+        "19": "s3",
+        "s4": "s4",
+        "20": "s4",
+        "s5": "s5",
+        "21": "s5",
+        "s6": "s6",
+        "22": "s6",
+        "s7": "s7",
+        "23": "s7",
+        # NOTE: Register #30 was originally the Frame Pointer.
+        # It's been re-aliased as s8, since many ABIs don't use the frame pointer.
+        # Unicorn and Sleigh prefer to use the alias s8,
+        # so it should be the base register.
+        "s8": "s8",
+        "fp": "s8",
+        "30": "s8",
+        # Kernel-reserved Registers
+        "k0": "k0",
+        "26": "k0",
+        "k1": "k1",
+        "27": "k1",
+        # *** Pointer Registers ***
+        # Zero register
+        "zero": "zero",
+        "0": "zero",
+        # Global Offset Pointer
+        "gp": "gp",
+        "28": "gp",
+        # Stack Pointer
+        "sp": "sp",
+        "29": "sp",
+        # Return Address
+        "ra": "ra",
+        "31": "ra",
+        # Program Counter
+        "pc": "pc",
+        # Floating Point Registers
+        "f0": "f0",
+        "f1": "f1",
+        "f2": "f2",
+        "f3": "f3",
+        "f4": "f4",
+        "f5": "f5",
+        "f6": "f6",
+        "f7": "f7",
+        "f8": "f8",
+        "f9": "f9",
+        "f10": "f10",
+        "f11": "f11",
+        "f12": "f12",
+        "f13": "f13",
+        "f14": "f14",
+        "f15": "f15",
+        "f16": "f16",
+        "f17": "f17",
+        "f18": "f18",
+        "f19": "f19",
+        "f20": "f20",
+        "f21": "f21",
+        "f22": "f22",
+        "f23": "f23",
+        "f24": "f24",
+        "f25": "f25",
+        "f26": "f26",
+        "f27": "f27",
+        "f28": "f28",
+        "f29": "f29",
+        "f30": "f30",
+        "f31": "f31",
+        # *** Floating Point Control Registers ***
+        "fir": "fir",
+        "fcsr": "fcsr",
+        "fexr": "fexr",
+        "fenr": "fenr",
+        "fccr": "fccr",
+        # *** Accumulator Registers ***
+        # MIPS uses these to implement 64-bit results
+        # from 32-bit multiplication, amongst others.
+        "ac0": None,
+        "hi0": None,
+        "lo0": None,
+        "ac1": None,
+        "hi1": None,
+        "lo1": None,
+        "ac2": None,
+        "hi2": None,
+        "lo2": None,
+        "ac3": None,
+        "hi3": None,
+        "lo3": None,
+    }
+
+    supports_single_step = True
+
+
+class MIPSELMachineDef(MIPSMachineDef):
+    byteorder = Byteorder.LITTLE
+    language_id = "MIPS:LE:32:default"
+
+
+class MIPSBEMachineDef(MIPSMachineDef):
+    byteorder = Byteorder.BIG
+    language_id = "MIPS:BE:32:default"

smallworld/emulators/ghidra/machdefs/mips64.py

@@ -0,0 +1,186 @@
+from ....platforms import Architecture, Byteorder
+from .machdef import GhidraMachineDef
+
+
+class MIPS64MachineDef(GhidraMachineDef):
+    arch = Architecture.MIPS64
+
+    # NOTE: MIPS registers have a name and a number
+    # angr's machine state doesn't use the number,
+    # so... name.
+    # NOTE: angr's register names are wrong.
+    # It follows Wikipedia's definition of the 64-bit ABI,
+    # which has a4 - a7 and t0 - t3 overlapping.
+    _registers = {
+        # *** General-Purpose Registers ***
+        # NOTE: Ghidra uses the O64 ABI (rather, it reuses the O32 names for both)
+        # SmallWorld uses the N64 ABI for mips64,
+        # so the argument and temporary registers will appear wrong
+        # Assembler-Temporary Register
+        "at": "at",
+        "1": "at",
+        # Return Value Registers
+        "v0": "v0",
+        "2": "v0",
+        "v1": "v1",
+        "3": "v1",
+        # Argument Registers
+        "a0": "a0",
+        "4": "a0",
+        "a1": "a1",
+        "5": "a1",
+        "a2": "a2",
+        "6": "a2",
+        "a3": "a3",
+        "7": "a3",
+        "a4": "t0",
+        "8": "t0",
+        "a5": "t1",
+        "9": "t1",
+        "a6": "t2",
+        "10": "t2",
+        "a7": "t3",
+        "11": "t3",
+        # Temporary Registers
+        "t0": "t4",
+        "12": "t4",
+        "t1": "t5",
+        "13": "t5",
+        "t2": "t6",
+        "14": "t6",
+        "t3": "t7",
+        "15": "t7",
+        # NOTE: These numbers aren't out of order.
+        # t8 and t9 are later in the register file than t0 - t7.
+        "t8": "t8",
+        "24": "t8",
+        "t9": "t9",
+        "25": "t9",
+        # Saved Registers
+        "s0": "s0",
+        "16": "s0",
+        "s1": "s1",
+        "17": "s1",
+        "s2": "s2",
+        "18": "s2",
+        "s3": "s3",
+        "19": "s3",
+        "s4": "s4",
+        "20": "s4",
+        "s5": "s5",
+        "21": "s5",
+        "s6": "s6",
+        "22": "s6",
+        "s7": "s7",
+        "23": "s7",
+        # NOTE: Register #30 was originally the Frame Pointer.
+        # It's been re-aliased as s8, since many ABIs don't use the frame pointer.
+        # Unicorn and Sleigh prefer to use the alias s8,
+        # so it should be the base register.
+        "s8": "s8",
+        "fp": "s8",
+        "30": "s8",
+        # Kernel-reserved Registers
+        "k0": "k0",
+        "26": "k0",
+        "k1": "k1",
+        "27": "k1",
+        # *** Pointer Registers ***
+        # Zero register
+        "zero": "zero",
+        "0": "zero",
+        # Global Offset Pointer
+        "gp": "gp",
+        "28": "gp",
+        # Stack Pointer
+        "sp": "sp",
+        "29": "sp",
+        # Return Address
+        "ra": "ra",
+        "31": "ra",
+        # Program Counter
+        "pc": "pc",
+        # Floating Point Registers
+        "f0": "f0",
+        "f1": "f1",
+        "f2": "f2",
+        "f3": "f3",
+        "f4": "f4",
+        "f5": "f5",
+        "f6": "f6",
+        "f7": "f7",
+        "f8": "f8",
+        "f9": "f9",
+        "f10": "f10",
+        "f11": "f11",
+        "f12": "f12",
+        "f13": "f13",
+        "f14": "f14",
+        "f15": "f15",
+        "f16": "f16",
+        "f17": "f17",
+        "f18": "f18",
+        "f19": "f19",
+        "f20": "f20",
+        "f21": "f21",
+        "f22": "f22",
+        "f23": "f23",
+        "f24": "f24",
+        "f25": "f25",
+        "f26": "f26",
+        "f27": "f27",
+        "f28": "f28",
+        "f29": "f29",
+        "f30": "f30",
+        "f31": "f31",
+        # *** Floating Point Control Registers ***
+        "fir": "fir",
+        "fcsr": "fcsr",
+        "fexr": "fexr",
+        "fenr": "fenr",
+        "fccr": "fccr",
+        # *** Accumulator Registers ***
+        # MIPS uses these to implement 64-bit results
+        # from 32-bit multiplication, amongst others.
+        "ac0": None,
+        "hi0": None,
+        "lo0": None,
+        "ac1": None,
+        "hi1": None,
+        "lo1": None,
+        "ac2": None,
+        "hi2": None,
+        "lo2": None,
+        "ac3": None,
+        "hi3": None,
+        "lo3": None,
+    }
+
+    _delay_slot_opcodes = {
+        "j",
+        "jal",
+        "jalx",
+        "jalr",
+        "jr",
+        "beq",
+        "beqz",
+        "bne" "bnez",
+        "bgez",
+        "bgezal",
+        "bgtz",
+        "blez",
+        "bltz",
+        "bltzal",
+    }
+
+    supports_single_step = True
+
+
+class MIPS64ELMachineDef(MIPS64MachineDef):
+    byteorder = Byteorder.LITTLE
+    language_id = "MIPS:LE:64:default"
+
+
+class MIPS64BEMachineDef(MIPS64MachineDef):
+    byteorder = Byteorder.BIG
+    language_id = "MIPS:BE:64:default"

smallworld/emulators/ghidra/machdefs/ppc.py

@@ -0,0 +1,98 @@
+from ....platforms import Architecture, Byteorder
+from .machdef import GhidraMachineDef
+
+
+class PowerPCMachineDef(GhidraMachineDef):
+    byteorder = Byteorder.BIG
+
+    _registers = {
+        "r0": "r0",
+        "r1": "r1",
+        "sp": "r1",
+        "r2": "r2",
+        "r3": "r3",
+        "r4": "r4",
+        "r5": "r5",
+        "r6": "r6",
+        "r7": "r7",
+        "r8": "r8",
+        "r9": "r9",
+        "r10": "r10",
+        "r11": "r11",
+        "r12": "r12",
+        "r13": "r13",
+        "r14": "r14",
+        "r15": "r15",
+        "r16": "r16",
+        "r17": "r17",
+        "r18": "r18",
+        "r19": "r19",
+        "r20": "r20",
+        "r21": "r21",
+        "r22": "r22",
+        "r23": "r23",
+        "r24": "r24",
+        "r25": "r25",
+        "r26": "r26",
+        "r27": "r27",
+        "r28": "r28",
+        "r29": "r29",
+        "r30": "r30",
+        "r31": "r31",
+        "bp": "r31",
+        "pc": "pc",
+        "lr": "lr",
+        "ctr": "ctr",
+        "cr0": "cr0",
+        "cr1": "cr1",
+        "cr2": "cr2",
+        "cr3": "cr3",
+        "cr4": "cr4",
+        "cr5": "cr5",
+        "cr6": "cr6",
+        "cr7": "cr7",
+        "f0": "f0",
+        "f1": "f1",
+        "f2": "f2",
+        "f3": "f3",
+        "f4": "f4",
+        "f5": "f5",
+        "f6": "f6",
+        "f7": "f7",
+        "f8": "f8",
+        "f9": "f9",
+        "f10": "f10",
+        "f11": "f11",
+        "f12": "f12",
+        "f13": "f13",
+        "f14": "f14",
+        "f15": "f15",
+        "f16": "f16",
+        "f17": "f17",
+        "f18": "f18",
+        "f19": "f19",
+        "f20": "f20",
+        "f21": "f21",
+        "f22": "f22",
+        "f23": "f23",
+        "f24": "f24",
+        "f25": "f25",
+        "f26": "f26",
+        "f27": "f27",
+        "f28": "f28",
+        "f29": "f29",
+        "f30": "f30",
+        "f31": "f31",
+        "xer": None,
+        "fpscr": None,
+    }
+
+
+class PowerPC32MachineDef(PowerPCMachineDef):
+    arch = Architecture.POWERPC32
+    language_id = "PowerPC:BE:32:default"
+
+
+class PowerPC64MachineDef(PowerPCMachineDef):
+    arch = Architecture.POWERPC64
+    language_id = "PowerPC:BE:64:default"