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

smallworld/state/models/mipsel/systemv/c99/string.py

@@ -0,0 +1,139 @@
+from ....c99 import (
+    Memchr,
+    Memcmp,
+    Memcpy,
+    Memmove,
+    Memset,
+    Strcat,
+    Strchr,
+    Strcmp,
+    Strcoll,
+    Strcpy,
+    Strcspn,
+    Strerror,
+    Strlen,
+    Strncat,
+    Strncmp,
+    Strncpy,
+    Strpbrk,
+    Strrchr,
+    Strspn,
+    Strstr,
+    Strtok,
+    Strxfrm,
+)
+from ..systemv import MIPSELSysVModel
+
+
+class MIPSELSysVMemcpy(Memcpy, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVMemmove(Memmove, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrcpy(Strcpy, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrncpy(Strncpy, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrcat(Strcat, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrncat(Strncat, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVMemcmp(Memcmp, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrncmp(Strncmp, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrcmp(Strcmp, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrcoll(Strcoll, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrxfrm(Strxfrm, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVMemchr(Memchr, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrchr(Strchr, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrcspn(Strcspn, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrpbrk(Strpbrk, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrrchr(Strrchr, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrspn(Strspn, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrstr(Strstr, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrtok(Strtok, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVMemset(Memset, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrerror(Strerror, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrlen(Strlen, MIPSELSysVModel):
+    pass
+
+
+__all__ = [
+    "MIPSELSysVMemcpy",
+    "MIPSELSysVMemmove",
+    "MIPSELSysVStrcpy",
+    "MIPSELSysVStrncpy",
+    "MIPSELSysVStrcat",
+    "MIPSELSysVStrncat",
+    "MIPSELSysVMemcmp",
+    "MIPSELSysVStrncmp",
+    "MIPSELSysVStrcmp",
+    "MIPSELSysVStrcoll",
+    "MIPSELSysVStrxfrm",
+    "MIPSELSysVMemchr",
+    "MIPSELSysVStrchr",
+    "MIPSELSysVStrcspn",
+    "MIPSELSysVStrpbrk",
+    "MIPSELSysVStrrchr",
+    "MIPSELSysVStrspn",
+    "MIPSELSysVStrstr",
+    "MIPSELSysVStrtok",
+    "MIPSELSysVMemset",
+    "MIPSELSysVStrerror",
+    "MIPSELSysVStrlen",
+]

smallworld/state/models/mipsel/systemv/c99/time.py

@@ -0,0 +1,61 @@
+from ....c99 import (
+    Asctime,
+    Clock,
+    Ctime,
+    Difftime,
+    Gmtime,
+    Localtime,
+    Mktime,
+    Strftime,
+    Time,
+)
+from ..systemv import MIPSELSysVModel
+
+
+class MIPSELSysVTime(Time, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVLocaltime(Localtime, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVGmtime(Gmtime, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVCtime(Ctime, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVAsctime(Asctime, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVStrftime(Strftime, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVDifftime(Difftime, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVMktime(Mktime, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVClock(Clock, MIPSELSysVModel):
+    pass
+
+
+__all__ = [
+    "MIPSELSysVTime",
+    "MIPSELSysVLocaltime",
+    "MIPSELSysVGmtime",
+    "MIPSELSysVCtime",
+    "MIPSELSysVAsctime",
+    "MIPSELSysVStrftime",
+    "MIPSELSysVDifftime",
+    "MIPSELSysVMktime",
+    "MIPSELSysVClock",
+]

smallworld/state/models/mipsel/systemv/posix/__init__.py

@@ -0,0 +1,6 @@
+from .libgen import *  # noqa: F401, F403
+from .libgen import __all__ as __libgen__
+from .signal import *  # noqa: F401, F403
+from .signal import __all__ as __signal__
+
+__all__ = __libgen__ + __signal__

smallworld/state/models/mipsel/systemv/posix/libgen.py

@@ -0,0 +1,16 @@
+from ....posix.libgen import Basename, Dirname
+from ..systemv import MIPSELSysVModel
+
+
+class MIPSELSysVBasename(Basename, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVDirname(Dirname, MIPSELSysVModel):
+    pass
+
+
+__all__ = [
+    "MIPSELSysVBasename",
+    "MIPSELSysVDirname",
+]

smallworld/state/models/mipsel/systemv/posix/signal.py

@@ -0,0 +1,157 @@
+from ....posix.signal import (
+    BsdSignal,
+    Kill,
+    Killpg,
+    PthreadKill,
+    PthreadSigmask,
+    Sigaction,
+    Sigaddset,
+    Sigaltstack,
+    Sigdelset,
+    Sigemptyset,
+    Sigfillset,
+    Sighold,
+    Sigignore,
+    Siginterrupt,
+    Sigismember,
+    Sigpause,
+    Sigpending,
+    Sigprocmask,
+    Sigqueue,
+    Sigrelse,
+    Sigset,
+    Sigsuspend,
+    Sigtimedwait,
+    Sigwait,
+    Sigwaitinfo,
+)
+from ..systemv import MIPSELSysVModel
+
+
+class MIPSELSysVBsdSignal(BsdSignal, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVKill(Kill, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVKillpg(Killpg, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVPthreadKill(PthreadKill, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVPthreadSigmask(PthreadSigmask, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigaction(Sigaction, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigaddset(Sigaddset, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigaltstack(Sigaltstack, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigdelset(Sigdelset, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigemptyset(Sigemptyset, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigfillset(Sigfillset, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSighold(Sighold, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigignore(Sigignore, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSiginterrupt(Siginterrupt, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigismember(Sigismember, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigpause(Sigpause, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigpending(Sigpending, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigprocmask(Sigprocmask, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigqueue(Sigqueue, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigrelse(Sigrelse, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigset(Sigset, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigsuspend(Sigsuspend, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigtimedwait(Sigtimedwait, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigwait(Sigwait, MIPSELSysVModel):
+    pass
+
+
+class MIPSELSysVSigwaitinfo(Sigwaitinfo, MIPSELSysVModel):
+    pass
+
+
+__all__ = [
+    "MIPSELSysVBsdSignal",
+    "MIPSELSysVKill",
+    "MIPSELSysVKillpg",
+    "MIPSELSysVPthreadKill",
+    "MIPSELSysVPthreadSigmask",
+    "MIPSELSysVSigaction",
+    "MIPSELSysVSigaddset",
+    "MIPSELSysVSigaltstack",
+    "MIPSELSysVSigdelset",
+    "MIPSELSysVSigemptyset",
+    "MIPSELSysVSigfillset",
+    "MIPSELSysVSighold",
+    "MIPSELSysVSigignore",
+    "MIPSELSysVSiginterrupt",
+    "MIPSELSysVSigismember",
+    "MIPSELSysVSigpause",
+    "MIPSELSysVSigpending",
+    "MIPSELSysVSigprocmask",
+    "MIPSELSysVSigqueue",
+    "MIPSELSysVSigrelse",
+    "MIPSELSysVSigset",
+    "MIPSELSysVSigsuspend",
+    "MIPSELSysVSigtimedwait",
+    "MIPSELSysVSigwait",
+    "MIPSELSysVSigwaitinfo",
+]

smallworld/state/models/mipsel/systemv/systemv.py

@@ -0,0 +1,78 @@
+import struct
+
+from ..... import emulators, platforms
+from ...cstd import ArgumentType, CStdModel
+
+
+class MIPSELSysVModel(CStdModel):
+    """Base class for C models using the MIPS o32 ABI"""
+
+    platform = platforms.Platform(
+        platforms.Architecture.MIPS32, platforms.Byteorder.LITTLE
+    )
+    abi = platforms.ABI.SYSTEMV
+
+    _int_sign_mask = 0x80000000
+    _int_inv_mask = 0xFFFFFFFF
+    _long_sign_mask = 0x80000000
+    _long_inv_mask = 0xFFFFFFFF
+    _long_long_sign_mask = 0x8000000000000000
+    _long_long_inv_mask = 0xFFFFFFFFFFFFFFFF
+
+    _four_byte_types = {
+        ArgumentType.INT,
+        ArgumentType.UINT,
+        ArgumentType.LONG,
+        ArgumentType.ULONG,
+        ArgumentType.SIZE_T,
+        ArgumentType.SSIZE_T,
+        ArgumentType.POINTER,
+    }
+
+    _eight_byte_types = {
+        ArgumentType.LONGLONG,
+        ArgumentType.ULONGLONG,
+    }
+
+    _four_byte_arg_regs = ["a0", "a1", "a2", "a3"]
+    _eight_byte_arg_regs = ["a0", "a1", "a2", "a3"]
+
+    _soft_float = True
+    _variadic_soft_float = True
+    _floats_are_doubles = False
+    _float_arg_regs = []
+    _double_arg_regs = []
+
+    _init_stack_offset = 16
+    _align_stack = True
+    _eight_byte_reg_size = 2
+    _double_reg_size = 2
+    _four_byte_stack_size = 4
+    _eight_byte_stack_size = 8
+    _float_stack_size = 4
+    _double_stack_size = 8
+
+    def _return_4_byte(self, emulator: emulators.Emulator, val: int) -> None:
+        emulator.write_register("v0", val)
+
+    def _return_8_byte(self, emulator: emulators.Emulator, val: int) -> None:
+        lo = val & self._int_inv_mask
+        hi = (val >> 32) & self._int_inv_mask
+
+        emulator.write_register("v0", lo)
+        emulator.write_register("v1", hi)
+
+    def _return_float(self, emulator: emulators.Emulator, val: float) -> None:
+        data = struct.pack("<f", val)
+        intval = int.from_bytes(data, "little")
+        emulator.write_register("f0", intval)
+
+    def _return_double(self, emulator: emulators.Emulator, val: float) -> None:
+        data = struct.pack("<d", val)
+        intval = int.from_bytes(data, "little")
+
+        lo = intval & self._int_inv_mask
+        hi = (intval >> 32) & self._int_inv_mask
+
+        emulator.write_register("f0", lo)
+        emulator.write_register("f1", hi)

smallworld/state/models/model.py

@@ -40,7 +40,6 @@ class Hook(state.Stateful):
 
 
 class Breakpoint(Hook):
-
     """An interactive breakpoint.
 
     Stops execution at the specified address and opens an interactive
@@ -85,13 +84,24 @@ class Model(Hook):
     function, e.g., libc `fread`. It is the responsibility of the
     model to read arguments and generate reasonable return values.
 
+    Some models require static scratch space to operate.
+    The quantity is stored in the 'static_space_required' attribute.
+    If true, the harness must set the 'static_buffer_address' property
+    of this model object.  The model will take care of mapping
+    a buffer of the appropriate size at that address.
+
+    A harness doesn't need to include a `Memory` object
+    for a static buffer.  A harness can include such an object
+    if it wants to initialize that memory with a specific value, or if it
+    wants to inspect the contents of that buffer via `Machine.extract()`
+
     Arguments:
         address: The address to model.
-
     """
 
     def __init__(self, address: int):
         super().__init__(address=address, function=self.model)
+        self.static_buffer_address: typing.Optional[int] = None
 
     @property
     @abc.abstractmethod
@@ -111,6 +121,8 @@ class Model(Hook):
         """The ABI according to which this model works."""
         pass
 
+    static_space_required: int = 0
+
     @classmethod
     def lookup(
         cls, name: str, platform: platforms.Platform, abi: platforms.ABI, address: int
@@ -137,7 +149,20 @@ class Model(Hook):
 
     def apply(self, emulator: emulators.Emulator) -> None:
         logger.debug(f"Hooking Model {self} {self._address:x}")
+
+        if self.static_space_required != 0:
+            # We need a static buffer.
+            if self.static_buffer_address is None:
+                # Harness author forgot to reserve us one
+                raise exceptions.ConfigurationError(
+                    f"No static buffer address provided for {self.name}"
+                )
+            emulator.map_memory(self.static_buffer_address, self.static_space_required)
+
+        # Map just enough memory to jump to the model address without faulting.
         emulator.map_memory(self._address, 16)
+
+        # Add the function hook to the emulator
         if not isinstance(emulator, emulators.FunctionHookable):
             raise exceptions.ConfigurationError("Emulator cannot hook functions")
         emulator.hook_function(self._address, self._function)

smallworld/state/models/posix/__init__.py

@@ -0,0 +1,6 @@
+from .libgen import *  # noqa: F401, F403
+from .libgen import __all__ as __libgen__
+from .signal import *  # noqa: F401, F403
+from .signal import __all__ as __signal__
+
+__all__ = __libgen__ + __signal__

smallworld/state/models/posix/libgen.py

@@ -0,0 +1,123 @@
+from .... import emulators
+from ..c99.utils import _emu_strlen
+from ..cstd import ArgumentType, CStdModel
+
+
+class Basename(CStdModel):
+    name = "basename"
+
+    # NOTE: There are two versions of basename().
+    #
+    # POSIX and GNU have competing specifications.
+    # They have the following differences:
+    #
+    # - GNU always uses a static buffer for its returns
+    # - GNU returns "" in case of trailing separators
+    # - GNU returns "" in case of the root path
+
+    # char *basename(char *path);
+    argument_types = [ArgumentType.POINTER]
+    return_type = ArgumentType.POINTER
+
+    # Use the GNU memory semantics
+    static_space_required = 0x1000
+
+    def __init__(self, address: int):
+        super().__init__(address)
+
+        # Override this to change how you parse paths
+        self.separator = b"/"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        super().model(emulator)
+
+        pathptr = self.get_arg1(emulator)
+
+        assert isinstance(pathptr, int)
+
+        # Not actually a loop; I just want to use break.
+        while True:
+            if pathptr == 0:
+                # Case: pathptr is NULL; return a static buffer containing '.'
+                path = b"."
+                break
+
+            pathlen = _emu_strlen(emulator, pathptr)
+            path = emulator.read_memory(pathptr, pathlen)
+
+            if path == self.separator:
+                # Case: Path is the root path: Return itself
+                break
+
+            if path[-1] == self.separator[0]:
+                # Case: Path ends in separator: Delete the trailing separator
+                path = path[0:-1]
+
+            if self.separator not in path:
+                # Case: no path separator: Return copy of path
+                break
+
+            # Case: Path has a separator in it: Return the trailing substring of path
+            idx = path.rindex(self.separator)
+            path = path[idx + 1 :]
+            break
+
+        assert self.static_buffer_address is not None
+
+        emulator.write_memory(self.static_buffer_address, path + b"\0")
+        self.set_return_value(emulator, self.static_buffer_address)
+
+
+class Dirname(CStdModel):
+    name = "dirname"
+
+    # char *dirname(char *path);
+    argument_types = [ArgumentType.POINTER]
+    return_type = ArgumentType.POINTER
+
+    def __init__(self, address: int):
+        super().__init__(address)
+
+        # Override this to change how you parse paths
+        self.separator = b"/"
+
+    def model(self, emulator: emulators.Emulator) -> None:
+        super().model(emulator)
+
+        pathptr = self.get_arg1(emulator)
+
+        assert isinstance(pathptr, int)
+
+        if pathptr == 0:
+            # Case: pathptr is NULL; return a static buffer containing '.'
+            raise NotImplementedError("Requires a static buffer")
+
+        pathlen = _emu_strlen(emulator, pathptr)
+        path = emulator.read_memory(pathptr, pathlen)
+
+        if path == self.separator:
+            # Case: Path is '/': Return itself
+            print("Root case")
+            self.set_return_value(emulator, pathptr)
+            return
+
+        if self.separator not in path:
+            # Case: No path separator; return '.'
+            emulator.write_memory(pathptr, b".\0")
+            self.set_return_value(emulator, pathptr)
+            return
+
+        if path[-1] == self.separator[0]:
+            path = path[:-2]
+
+        idx = path.rindex(self.separator)
+        if idx == 0:
+            # Case: Path's lowest '/' is the root path; return '/'
+            emulator.write_memory(pathptr + idx + 1, b"\0")
+        else:
+            # Case: Path has a '/' in it.  Replace it with \0 and return original pointer
+            emulator.write_memory(pathptr + idx, b"\0")
+        self.set_return_value(emulator, pathptr)
+
+
+__all__ = ["Basename", "Dirname"]