hilda 3.0.1__py3-none-any.whl → 3.2.1__py3-none-any.whl

hilda/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '3.0.1'
-__version_tuple__ = version_tuple = (3, 0, 1)
+__version__ = version = '3.2.1'
+__version_tuple__ = version_tuple = (3, 2, 1)
+
+__commit_id__ = commit_id = None

hilda/breakpoints.py

@@ -124,12 +124,30 @@ class HildaBreakpoint:
         for name in names_to_add:
             self.lldb_breakpoint.AddName(name)
 
+    @property
+    def enabled(self) -> bool:
+        """
+        Configures whether this breakpoint is enabled or not.
+        """
+        return self.lldb_breakpoint.IsEnabled()
+
+    @enabled.setter
+    def enabled(self, value: bool) -> None:
+        self.lldb_breakpoint.SetEnabled(value)
+
     def __repr__(self) -> str:
-        return (f'<{self.__class__.__name__} LLDB:{self.lldb_breakpoint} GUARDED:{self.guarded} '
+        enabled_repr = 'ENABLED' if self.enabled else 'DISABLED'
+        guarded_repr = 'GUARDED' if self.guarded else 'NOT-GUARDED'
+        return (f'<{self.__class__.__name__} LLDB:{self.lldb_breakpoint} {enabled_repr} {guarded_repr} '
                 f'CALLBACK:{self.callback}>')
 
     def __str__(self) -> str:
-        result = f'🚨 Breakpoint #{self.id} (guarded: {self.guarded}):\n'
+        emoji = '🚨' if self.enabled else '🔕'
+        enabled_str = 'enabled' if self.enabled else 'disabled'
+        guarded_str = 'guarded' if self.guarded else 'not-guarded'
+
+        result = f'{emoji} Breakpoint #{self.id} ({enabled_str}, {guarded_str})\n'
+
         if self.description is not None:
             result += f'\tDescription: {self.description}\n'
 
@@ -137,10 +155,13 @@ class HildaBreakpoint:
             result += f'\tWhere: {self.where}\n'
 
         # A single breakpoint may be related to several locations (addresses)
+        locations = self.locations
+        if len(locations) == 0:
+            result += '\tNo locations\n'
         for location in self.locations:
             result += f'\tLocation {location}\n'
 
-        return result
+        return result.strip('\n')
 
     def remove(self, remove_guarded: bool = False) -> None:
         """
@@ -206,6 +227,7 @@ class BreakpointList:
         if it does not exist.
 
         :param id_or_name_or_bp: Breakpoint's ID or name (or the breakpoint itself)
+        :return: `HildaBreakpoint` if one exists, or `None` otherwise
         """
 
         if isinstance(id_or_name_or_bp, int):
@@ -341,14 +363,13 @@ class BreakpointList:
             :param frame: LLDB frame
             :param bp_loc: LLDB breakpoint location
             """
-            nonlocal regs, expr, retval, stop, bt, cmd, force_return, name
+            nonlocal name
             bp = bp_loc.GetBreakpoint()
             symbol = hilda.symbol(hilda.frame.addr.GetLoadAddress(hilda.target))
             thread = hilda.thread
-            printed_name = name if name is not None else str(symbol.lldb_symbol)
+            printed_name = name if name is not None else str(symbol.lldb_address)
 
             def format_value(fmt: Union[str, Callable], value: Symbol) -> str:
-                nonlocal hilda
                 if callable(fmt):
                     return fmt(hilda, value)
                 formatters = {
@@ -441,8 +462,10 @@ class BreakpointList:
 
     def show(self) -> None:
         """ Show existing breakpoints. """
+        if len(self) == 0:
+            self._hilda.log_info('No breakpoints')
         for bp in self:
-            print(bp)
+            self._hilda.log_info(bp)
 
     def items(self):
         """

hilda/decorators.py

@@ -0,0 +1,46 @@
+from hilda.breakpoints import WhereType
+from hilda.lldb_importer import lldb
+
+p = lldb.hilda_client
+
+
+def breakpoint(where: WhereType, enable: bool = False):
+    """
+    A decorator to define a breakpoint, e.g.,
+
+    ```
+    @breakpoint('symbol_name')
+    def my_breakpoint(hilda, *args):
+        print('Hit!')
+        hilda.cont()
+
+    my_breakpoint.enabled = True
+    ```
+    """
+    def decorator(callback):
+        bp = p.breakpoints.add(where, callback=callback)
+        bp.enabled = enable
+        return bp
+
+    return decorator
+
+
+def watchpoint(where: int, enable: bool = False):
+    """
+    A decorator to define a watchpoint, e.g.,
+
+    ```
+    @watchpoint(0x11223344)
+    def my_watchpoint(hilda, *args):
+        print('Hit!')
+        hilda.cont()
+
+    my_watchpoint.enabled = True
+    ```
+    """
+    def decorator(callback):
+        wp = p.watchpoints.add(where, callback=callback)
+        wp.enabled = enable
+        return wp
+
+    return decorator

hilda/exceptions.py

@@ -1,7 +1,7 @@
 __all__ = ['HildaException', 'SymbolAbsentError', 'EvaluatingExpressionError', 'CreatingObjectiveCSymbolError',
            'ConvertingToNsObjectError', 'ConvertingFromNSObjectError', 'DisableJetsamMemoryChecksError',
            'GettingObjectiveCClassError', 'AccessingRegisterError', 'AccessingMemoryError',
-           'BrokenLocalSymbolsJarError', 'AddingLldbSymbolError', 'LLDBError', 'InvalidThreadIndexError']
+           'AddingLldbSymbolError', 'LLDBError', 'InvalidThreadIndexError']
 
 
 class HildaException(Exception):
@@ -59,11 +59,6 @@ class AccessingMemoryError(HildaException):
     pass
 
 
-class BrokenLocalSymbolsJarError(HildaException):
-    """ Raise when attempt to load an invalid symbols jar pickle """
-    pass
-
-
 class AddingLldbSymbolError(HildaException):
     """ Raise when failing to convert a LLDB symbol to Hilda's symbol. """
     pass

hilda/hilda_client.py

@@ -10,7 +10,7 @@ import sys
 import time
 import typing
 from collections import namedtuple
-from contextlib import contextmanager, suppress
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from functools import cached_property, wraps
@@ -30,17 +30,16 @@ from traitlets.config import Config
 from hilda import objective_c_class
 from hilda.breakpoints import BreakpointList, HildaBreakpoint, WhereType
 from hilda.common import CfSerializable, selection_prompt
-from hilda.exceptions import AccessingMemoryError, AccessingRegisterError, AddingLldbSymbolError, \
-    ConvertingFromNSObjectError, ConvertingToNsObjectError, CreatingObjectiveCSymbolError, \
-    DisableJetsamMemoryChecksError, EvaluatingExpressionError, HildaException, InvalidThreadIndexError, \
-    SymbolAbsentError
+from hilda.exceptions import AccessingMemoryError, AccessingRegisterError, ConvertingFromNSObjectError, \
+    ConvertingToNsObjectError, CreatingObjectiveCSymbolError, DisableJetsamMemoryChecksError, \
+    EvaluatingExpressionError, HildaException, InvalidThreadIndexError, SymbolAbsentError
 from hilda.ipython_extensions.keybindings import get_keybindings
 from hilda.lldb_importer import lldb
 from hilda.objective_c_symbol import ObjectiveCSymbol
 from hilda.registers import Registers
 from hilda.snippets.mach import CFRunLoopServiceMachPort_hooks
 from hilda.symbol import Symbol
-from hilda.symbols_jar import SymbolsJar
+from hilda.symbols import SymbolList
 from hilda.ui.ui_manager import UiManager
 from hilda.watchpoints import WatchpointList
 
@@ -127,7 +126,7 @@ class HildaClient:
         self.debugger = debugger
         self.target = debugger.GetSelectedTarget()
         self.process = self.target.GetProcess()
-        self.symbols = SymbolsJar.create(self)
+        self.symbols = SymbolList(self)
         self.breakpoints = BreakpointList(self)
         self.watchpoints = WatchpointList(self)
         self.captured_objects = {}
@@ -201,7 +200,7 @@ class HildaClient:
         :param address:
         :return: Hilda's symbol object
         """
-        return Symbol.create(address, self)
+        return self.symbols.add(address)
 
     def objc_symbol(self, address: int) -> ObjectiveCSymbol:
         """
@@ -214,18 +213,18 @@ class HildaClient:
         except HildaException as e:
             raise CreatingObjectiveCSymbolError from e
 
-    def inject(self, filename: str) -> SymbolsJar:
+    def inject(self, filename: str) -> SymbolList:
         """
         Inject a single library into currently running process.
 
         :param filename: library to inject (dylib)
-        :return: SymbolsJar
+        :return: SymbolList
         """
         module = self.target.FindModule(lldb.SBFileSpec(os.path.basename(filename), False))
         if module.file.basename is not None:
             self.log_warning(f'file {filename} has already been loaded')
 
-        injected = SymbolsJar.create(self)
+        injected = SymbolList(self)
         handle = self.symbols.dlopen(filename, 10)  # RTLD_GLOBAL|RTLD_NOW
 
         if handle == 0:
@@ -247,34 +246,9 @@ class HildaClient:
                 # ignore unnamed symbols and those which are not: data, code or objc classes
                 continue
 
-            injected[name] = self.symbol(load_addr)
+            injected.add(self.symbol(load_addr), name)
         return injected
 
-    def rebind_symbols(self, image_range=None, filename_expr=''):
-        """
-        Reparse all loaded images symbols
-        :param image_range: index range for images to load in the form of [start, end]
-        :param filename_expr: filter only images containing given expression
-        """
-        self.log_debug('mapping symbols')
-        self._symbols_loaded = False
-
-        for i, module in enumerate(tqdm(self.target.modules)):
-            filename = module.file.basename
-
-            if filename_expr not in filename:
-                continue
-
-            if image_range is not None and (i < image_range[0] or i > image_range[1]):
-                continue
-
-            for symbol in module:
-                with suppress(AddingLldbSymbolError):
-                    self.add_lldb_symbol(symbol)
-
-        globals()['symbols'] = self.symbols
-        self._symbols_loaded = True
-
     @stop_is_needed
     def poke(self, address, buf: bytes):
         """
@@ -594,7 +568,7 @@ class HildaClient:
         """ jump to given symbol """
         self.lldb_handle_command(f'j *{symbol}')
 
-    def lldb_handle_command(self, cmd: str) -> None:
+    def lldb_handle_command(self, cmd: str, capture_output: bool = False) -> Optional[str]:
         """
         Execute an LLDB command
 
@@ -602,8 +576,15 @@ class HildaClient:
             lldb_handle_command('register read')
 
         :param cmd: LLDB command
+        :param capture_output: True if capturing the command output
+        :return: The output if capture was requested, None if not or the command failed
         """
-        self.debugger.HandleCommand(cmd)
+        if capture_output:
+            result = lldb.SBCommandReturnObject()
+            self.debugger.GetCommandInterpreter().HandleCommand(cmd, result)
+            return result.GetOutput() if result.Succeeded() else None
+        else:
+            self.debugger.HandleCommand(cmd)
 
     def objc_get_class(self, name: str, module_name: Optional[str] = None) -> objective_c_class.Class:
         """
@@ -828,36 +809,6 @@ class HildaClient:
         """ Log at info level """
         self.logger.info(message)
 
-    def add_lldb_symbol(self, symbol: lldb.SBSymbol) -> Symbol:
-        """
-        Convert an LLDB symbol into Hilda's symbol object and insert into `symbols` global
-        :param symbol: LLDB symbol
-        :return: converted symbol
-        :raise AddingLldbSymbolError: Hilda failed to convert the LLDB symbol.
-        """
-        load_addr = symbol.addr.GetLoadAddress(self.target)
-        if load_addr == 0xffffffffffffffff:
-            # skip those not having a real address
-            raise AddingLldbSymbolError()
-
-        name = symbol.name
-        type_ = symbol.GetType()
-
-        if name in ('<redacted>',) or (type_ not in (lldb.eSymbolTypeCode,
-                                                     lldb.eSymbolTypeRuntime,
-                                                     lldb.eSymbolTypeData,
-                                                     lldb.eSymbolTypeObjCMetaClass)):
-            # ignore unnamed symbols and those which are not in a really used type
-            raise AddingLldbSymbolError()
-
-        value = self.symbol(load_addr)
-
-        # add it into symbols global
-        self.symbols[name] = value
-        self.symbols[f'{name}{{{value.filename}}}'] = value
-
-        return value
-
     def wait_for_module(self, expression: str) -> None:
         """ Wait for a module to be loaded using `dlopen` by matching given expression """
         self.log_info(f'Waiting for module name containing "{expression}" to be loaded')
@@ -901,7 +852,7 @@ class HildaClient:
 
         # Configure and start IPython shell
         ipython_config = Config()
-        ipython_config.IPCompleter.use_jedi = True
+        ipython_config.IPCompleter.use_jedi = False
         ipython_config.BaseIPythonApplication.profile = 'hilda'
         ipython_config.InteractiveShellApp.extensions = ['hilda.ipython_extensions.magics',
                                                          'hilda.ipython_extensions.events',

hilda/ipython_extensions/events.py

@@ -3,10 +3,9 @@ import builtins
 
 from IPython.terminal.interactiveshell import TerminalInteractiveShell
 
-from hilda.exceptions import EvaluatingExpressionError, SymbolAbsentError
+from hilda.exceptions import EvaluatingExpressionError
 from hilda.hilda_client import HildaClient
 from hilda.lldb_importer import lldb
-from hilda.symbols_jar import SymbolsJar
 
 
 class HIEvents:
@@ -30,22 +29,19 @@ class HIEvents:
                 # That are undefined
                 continue
 
-            if not hasattr(SymbolsJar, node.id):
-                # ignore SymbolsJar properties
-                try:
-                    symbol = getattr(self.hilda_client.symbols, node.id)
-                except SymbolAbsentError:
-                    pass
-                else:
-                    try:
-                        self.hilda_client._add_global(
-                            node.id,
-                            symbol if symbol.type_ != lldb.eSymbolTypeObjCMetaClass else self.hilda_client.objc_get_class(
-                                node.id)
-                        )
-                    except EvaluatingExpressionError:
-                        self.hilda_client.log_warning(
-                            f'Process is running. Pause execution in order to resolve "{node.id}"')
+            symbol = self.hilda_client.symbols.get(node.id)
+            if symbol is None:
+                continue
+
+            try:
+                self.hilda_client._add_global(
+                    node.id,
+                    symbol if symbol.type_ != lldb.eSymbolTypeObjCMetaClass else self.hilda_client.objc_get_class(
+                        node.id)
+                )
+            except EvaluatingExpressionError:
+                self.hilda_client.log_warning(
+                    f'Process is running. Pause execution in order to resolve "{node.id}"')
 
 
 def load_ipython_extension(ip: TerminalInteractiveShell):

hilda/objective_c_class.py

@@ -1,9 +1,9 @@
 import json
 import time
-from collections import namedtuple
+from collections import UserList, namedtuple
 from dataclasses import dataclass, field
 from functools import partial
-from typing import Any
+from typing import Any, Optional
 
 from objc_types_decoder.decode import decode as decode_type
 from objc_types_decoder.decode import decode_with_tail
@@ -12,7 +12,6 @@ from pygments.formatters import TerminalTrueColorFormatter
 from pygments.lexers import ObjectiveCLexer
 
 from hilda.exceptions import GettingObjectiveCClassError
-from hilda.symbols_jar import SymbolsJar
 
 Ivar = namedtuple('Ivar', 'name type_ offset')
 Property = namedtuple('Property', 'name attributes')
@@ -88,6 +87,86 @@ class Method:
         return f'{prefix} {name}; // 0x{self.address:x} (returns: {self.return_type})\n'
 
 
+class MethodList(UserList):
+    def __init__(self, class_name: str, methods: list[Method]) -> None:
+        super().__init__()
+        self._class_name = class_name
+        self.data = methods
+
+    def get(self, name: str) -> Optional[Method]:
+        """
+        Get a specific method implementation.
+        :param name: Method name.
+        :return: Method.
+        """
+        for method in self.data:
+            if method.name == name:
+                return method
+        return None
+
+    # Actions
+
+    def bp(self, callback=None, **kwargs):
+        """
+        Place a breakpoint on all symbols in the method list.
+        Look for the bp command for more details.
+        :param callback:  callback function to be executed upon an hit
+        :param kwargs: optional kwargs for the bp command
+        """
+        for method in self.data:
+            kwargs['name'] = f'[{self._class_name} {method.name}]'
+            method.imp.bp(callback, **kwargs)
+
+    def monitor(self, **kwargs):
+        """
+        Perform monitor for all symbols in the method list.
+        See monitor command for more details.
+        :param args: given arguments for monitor command
+        """
+        for method in self.data:
+            method.imp.monitor(**kwargs)
+
+    # Filters
+
+    def filter_startswith(self, exp, case_sensitive=True):
+        """
+        Filter only methods with given prefix
+        :param exp: prefix
+        :param case_sensitive: is case sensitive
+        :return: reduced method list
+        """
+        if not case_sensitive:
+            exp = exp.lower()
+
+        retval = []
+        for v in self.data:
+            name = v.name
+            if not case_sensitive:
+                name = name.lower()
+            if name.startswith(exp):
+                retval.append(v)
+        return MethodList(self._class_name, retval)
+
+    def filter_name_contains(self, exp, case_sensitive=True):
+        """
+        Filter methods containing a given expression
+        :param exp: given expression
+        :param case_sensitive: is case sensitive
+        :return: reduced method list
+        """
+        if not case_sensitive:
+            exp = exp.lower()
+
+        retval = []
+        for v in self.data:
+            name = v.name
+            if not case_sensitive:
+                name = name.lower()
+            if exp in name:
+                retval.append(v)
+        return MethodList(self._class_name, retval)
+
+
 class Class:
     """
     Wrapper for ObjectiveC Class object.
@@ -103,8 +182,8 @@ class Class:
         self.protocols = []
         self.ivars = []
         self.properties = []
-        self.methods = []
         self.name = ''
+        self.methods = MethodList(self.name, [])
         self.super = None
         if class_data is None:
             self.reload()
@@ -160,16 +239,6 @@ class Class:
         """
         return self._class_object.objc_call(sel, *args)
 
-    def get_method(self, name: str):
-        """
-        Get a specific method implementation.
-        :param name: Method name.
-        :return: Method.
-        """
-        for method in self.methods:
-            if method.name == name:
-                return method
-
     def capture_self(self, sync: bool = False):
         """
         Capture the first called `self` from this class.
@@ -210,15 +279,13 @@ class Class:
         """
         Proxy for monitor command.
         """
-        self.symbols_jar.monitor(**kwargs)
+        self.methods.monitor(**kwargs)
 
     def bp(self, callback=None, **kwargs):
         """
         Proxy for bp command.
         """
-        for method in self.methods:
-            kwargs['name'] = f'[{self.name} {method.name}]'
-            method.imp.bp(callback, **kwargs)
+        self.methods.bp(callback, **kwargs)
 
     def iter_supers(self):
         """
@@ -243,17 +310,7 @@ class Class:
             Property(name=prop['name'], attributes=convert_encoded_property_attributes(prop['attributes']))
             for prop in data['properties']
         ]
-        self.methods = [Method.from_data(method, self._client) for method in data['methods']]
-
-    @property
-    def symbols_jar(self) -> SymbolsJar:
-        """ Get a SymbolsJar object for quick operations on all methods """
-        jar = SymbolsJar.create(self._client)
-
-        for m in self.methods:
-            jar[f'[{self.name} {m.name}]'] = m.imp
-
-        return jar
+        self.methods = MethodList(self.name, [Method.from_data(method, self._client) for method in data['methods']])
 
     def __dir__(self):
         result = set()

hilda/objective_c_symbol.py

@@ -9,9 +9,8 @@ from pygments.formatters import TerminalTrueColorFormatter
 from pygments.lexers import ObjectiveCLexer
 
 from hilda.exceptions import HildaException
-from hilda.objective_c_class import Class, Method, Property, convert_encoded_property_attributes
+from hilda.objective_c_class import Class, Method, MethodList, Property, convert_encoded_property_attributes
 from hilda.symbol import Symbol
-from hilda.symbols_jar import SymbolsJar
 
 
 class SettingIvarError(HildaException):
@@ -45,7 +44,7 @@ class ObjectiveCSymbol(Symbol):
         symbol = super().create(value, client)
         symbol.ivars = []  # type: List[Ivar]
         symbol.properties = []  # type: List[Property]
-        symbol.methods = []  # type: List[Method]
+        symbol.methods = MethodList('', [])  # type: MethodList
         symbol.class_ = None  # type: Optional[Class]
         symbol.reload()
         return symbol
@@ -56,7 +55,7 @@ class ObjectiveCSymbol(Symbol):
         """
         self.ivars.clear()
         self.properties.clear()
-        self.methods.clear()
+        self.methods = MethodList('', [])
         self.class_ = None
 
         obj_c_code = (self._client._hilda_root / 'objective_c' / 'get_objectivec_symbol_data.m').read_text()
@@ -65,12 +64,12 @@ class ObjectiveCSymbol(Symbol):
 
         self._reload_ivars(data['ivars'])
         self._reload_properties(data['properties'])
-        self.methods = [Method.from_data(method, self._client) for method in data['methods']]
 
         data['name'] = data['class_name']
         data['address'] = data['class_address']
         data['super'] = data['class_super']
         self.class_ = Class(self._client, self._client.symbol(data['class_address']), data)
+        self.methods = MethodList(self.class_.name, [Method.from_data(method, self._client) for method in data['methods']])
 
     def show(self, recursive: bool = False):
         """
@@ -141,7 +140,7 @@ class ObjectiveCSymbol(Symbol):
                 buf += f'@synthesize {prop.name} = {attrs.synthesize};\n'
 
         # Add methods
-        methods = self.methods.copy()
+        methods = list(self.methods)
 
         # Add super methods.
         if recursive:
@@ -158,16 +157,6 @@ class ObjectiveCSymbol(Symbol):
         buf += '@end'
         return buf
 
-    @property
-    def symbols_jar(self) -> SymbolsJar:
-        """ Get a SymbolsJar object for quick operations on all methods """
-        jar = SymbolsJar.create(self._client)
-
-        for m in self.methods:
-            jar[m.name] = m.address
-
-        return jar
-
     def __dir__(self):
         result = set()
 

hilda/snippets/libmalloc.py

@@ -93,15 +93,15 @@ class NanoV2Arena:
     def __init__(self, arena_base_addr):
         self.nanov2_arena_struct = Struct(
             # Note that this only parses 1 CPU memblock (1MB). Modify it to be 64.
-            *[\
-                f"blocks_{idx}" / Array(self.blocks_per_size[idx], \
-                                        Struct('content' / \
-                                               Array(self.slots_per_size[idx], \
-                                                     Struct('Q' / Bytes(self.size_per_slot[idx]) \
-                                                            )\
-                                                     )\
-                                               ))\
-                for idx in range(len(self.blocks_per_size))\
+            *[
+                f"blocks_{idx}" / Array(self.blocks_per_size[idx],
+                                        Struct('content' /
+                                               Array(self.slots_per_size[idx],
+                                                     Struct('Q' / Bytes(self.size_per_slot[idx])
+                                                            )
+                                                     )
+                                               ))
+                for idx in range(len(self.blocks_per_size))
             ]
         )
         self.arena_struct = self.nanov2_arena_struct.parse_stream(arena_base_addr)