Skip to content

libdebug.state.thread_context

ThreadContext

Bases: ABC

This object represents a thread in the context of the target process. It holds information about the thread's state, registers and stack.

Source code in libdebug/state/thread_context.py 
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
class ThreadContext(ABC):
    """This object represents a thread in the context of the target process. It holds information about the thread's state, registers and stack."""

    instruction_pointer: int
    """The thread's instruction pointer."""

    syscall_arg0: int
    """The thread's syscall argument 0."""

    syscall_arg1: int
    """The thread's syscall argument 1."""

    syscall_arg2: int
    """The thread's syscall argument 2."""

    syscall_arg3: int
    """The thread's syscall argument 3."""

    syscall_arg4: int
    """The thread's syscall argument 4."""

    syscall_arg5: int
    """The thread's syscall argument 5."""

    syscall_number: int
    """The thread's syscall number."""

    syscall_return: int
    """The thread's syscall return value."""

    regs: Registers
    """The thread's registers."""

    _internal_debugger: InternalDebugger | None = None
    """The debugging context this thread belongs to."""

    _register_holder: RegisterHolder | None = None
    """The register holder object."""

    _dead: bool = False
    """Whether the thread is dead."""

    _exit_code: int | None = None
    """The thread's exit code."""

    _exit_signal: int | None = None
    """The thread's exit signal."""

    _signal_number: int = 0
    """The signal to forward to the thread."""

    _thread_id: int
    """The thread's ID."""

    _snapshot_count: int = 0
    """The number of snapshots taken."""

    _zombie: bool = False
    """Whether the thread is a zombie."""

    def __init__(self: ThreadContext, thread_id: int, registers: RegisterHolder) -> None:
        """Initializes the Thread Context."""
        self._internal_debugger = provide_internal_debugger(self)
        self._thread_id = thread_id
        self._register_holder = registers
        regs_class = self._register_holder.provide_regs_class()
        self.regs = regs_class(thread_id, self._register_holder.provide_regs())
        self._register_holder.apply_on_regs(self.regs, regs_class)

    def set_as_dead(self: ThreadContext) -> None:
        """Set the thread as dead."""
        self._dead = True

    @property
    def debugger(self: ThreadContext) -> Debugger:
        """The debugging context this thread belongs to."""
        return self._internal_debugger.debugger

    @property
    def dead(self: ThreadContext) -> bool:
        """Whether the thread is dead."""
        return self._dead

    @property
    def memory(self: ThreadContext) -> AbstractMemoryView:
        """The memory view of the debugged process."""
        return self._internal_debugger.memory

    @property
    def mem(self: ThreadContext) -> AbstractMemoryView:
        """Alias for the `memory` property.

        Get the memory view of the process.
        """
        return self._internal_debugger.memory

    @property
    def process_id(self: ThreadContext) -> int:
        """The process ID."""
        return self._internal_debugger.process_id

    @property
    def pid(self: ThreadContext) -> int:
        """Alias for `process_id` property.

        The process ID.
        """
        return self._internal_debugger.process_id

    @property
    def thread_id(self: ThreadContext) -> int:
        """The thread ID."""
        return self._thread_id

    @property
    def tid(self: ThreadContext) -> int:
        """The thread ID."""
        return self._thread_id

    @property
    def running(self: ThreadContext) -> bool:
        """Whether the process is running."""
        return self._internal_debugger.running

    @property
    def saved_ip(self: ThreadContext) -> int:
        """The return address of the current function."""
        self._internal_debugger._ensure_process_stopped()
        stack_unwinder = stack_unwinding_provider(self._internal_debugger.arch)

        try:
            return_address = stack_unwinder.get_return_address(self, self._internal_debugger.maps)
        except (OSError, ValueError) as e:
            raise ValueError(
                "Failed to get the return address. Check stack frame registers (e.g., base pointer).",
            ) from e

        return return_address

    @property
    def exit_code(self: ThreadContext) -> int | None:
        """The thread's exit code."""
        self._internal_debugger._ensure_process_stopped()
        if not self.dead:
            liblog.warning("Thread is not dead. No exit code available.")
        elif self._exit_code is None and self._exit_signal is not None:
            liblog.warning(
                "Thread exited with signal %s. No exit code available.",
                resolve_signal_name(self._exit_signal),
            )
        return self._exit_code

    @property
    def exit_signal(self: ThreadContext) -> str | None:
        """The thread's exit signal."""
        self._internal_debugger._ensure_process_stopped()
        if not self.dead:
            liblog.warning("Thread is not dead. No exit signal available.")
            return None
        elif self._exit_signal is None and self._exit_code is not None:
            liblog.warning("Thread exited with code %d. No exit signal available.", self._exit_code)
            return None
        return resolve_signal_name(self._exit_signal)

    @property
    def signal(self: ThreadContext) -> str | None:
        """The signal will be forwarded to the thread."""
        self._internal_debugger._ensure_process_stopped()
        return None if self._signal_number == 0 else resolve_signal_name(self._signal_number)

    @signal.setter
    def signal(self: ThreadContext, signal: str | int) -> None:
        """Set the signal to forward to the thread."""
        self._internal_debugger._ensure_process_stopped()
        if self._signal_number != 0:
            liblog.debugger(
                f"Overwriting signal {resolve_signal_name(self._signal_number)} with {resolve_signal_name(signal) if isinstance(signal, int) else signal}.",
            )
        if isinstance(signal, str):
            signal = resolve_signal_number(signal)
        self._signal_number = signal
        self._internal_debugger.resume_context.threads_with_signals_to_forward.append(self.thread_id)

    @property
    def signal_number(self: ThreadContext) -> int:
        """The signal number to forward to the thread."""
        return self._signal_number

    @property
    def zombie(self: ThreadContext) -> bool:
        """Whether the thread is a zombie."""
        return self._zombie

    def backtrace(self: ThreadContext, as_symbols: bool = False) -> list:
        """Returns the current backtrace of the thread.

        Args:
            as_symbols (bool, optional): Whether to return the backtrace as symbols
        """
        self._internal_debugger._ensure_process_stopped()
        stack_unwinder = stack_unwinding_provider(self._internal_debugger.arch)
        backtrace = stack_unwinder.unwind(self)
        if as_symbols:
            maps = self._internal_debugger.debugging_interface.get_maps()
            with extend_internal_debugger(self._internal_debugger):
                backtrace = [resolve_address_in_maps(x, maps) for x in backtrace]
        return backtrace

    def pprint_backtrace(self: ThreadContext) -> None:
        """Pretty prints the current backtrace of the thread."""
        self._internal_debugger._ensure_process_stopped()
        stack_unwinder = stack_unwinding_provider(self._internal_debugger.arch)
        backtrace = stack_unwinder.unwind(self)
        maps = self._internal_debugger.debugging_interface.get_maps()
        pprint_backtrace_util(backtrace, maps, self._internal_debugger.symbols)

    def pprint_registers(self: ThreadContext) -> None:
        """Pretty prints the thread's registers."""
        pprint_registers_util(
            self.regs,
            self._internal_debugger.maps,
            self._register_holder.provide_regs(),
        )

    def pprint_regs(self: ThreadContext) -> None:
        """Alias for the `pprint_registers` method.

        Pretty prints the thread's registers.
        """
        self.pprint_registers()

    def pprint_registers_all(self: ThreadContext) -> None:
        """Pretty prints all the thread's registers."""
        pprint_registers_all_util(
            self.regs,
            self._internal_debugger.maps,
            self._register_holder.provide_regs(),
            self._register_holder.provide_special_regs(),
            self._register_holder.provide_vector_fp_regs(),
        )

    def pprint_regs_all(self: ThreadContext) -> None:
        """Alias for the `pprint_registers_all` method.

        Pretty prints all the thread's registers.
        """
        self.pprint_registers_all()

    def step(self: ThreadContext) -> None:
        """Executes a single instruction of the process."""
        self._internal_debugger.step(self)

    def step_until(
        self: ThreadContext,
        position: int | str,
        max_steps: int = -1,
        file: str = "hybrid",
    ) -> None:
        """Executes instructions of the process until the specified location is reached.

        Args:
            position (int | bytes): The location to reach.
            max_steps (int, optional): The maximum number of steps to execute. Defaults to -1.
            file (str, optional): The user-defined backing file to resolve the address in. Defaults to "hybrid" (libdebug will first try to solve the address as an absolute address, then as a relative address w.r.t. the "binary" map file).
        """
        self._internal_debugger.step_until(self, position, max_steps, file)

    def finish(self: ThreadContext, heuristic: str = "backtrace") -> None:
        """Continues execution until the current function returns or the process stops.

        The command requires a heuristic to determine the end of the function. The available heuristics are:
        - `backtrace`: The debugger will place a breakpoint on the saved return address found on the stack and continue execution on all threads.
        - `step-mode`: The debugger will step on the specified thread until the current function returns. This will be slower.

        Args:
            heuristic (str, optional): The heuristic to use. Defaults to "backtrace".
        """
        self._internal_debugger.finish(self, heuristic=heuristic)

    def next(self: ThreadContext) -> None:
        """Executes the next instruction of the process. If the instruction is a call, the debugger will continue until the called function returns."""
        self._internal_debugger.next(self)

    def si(self: ThreadContext) -> None:
        """Alias for the `step` method.

        Executes a single instruction of the process.
        """
        self._internal_debugger.step(self)

    def su(
        self: ThreadContext,
        position: int | str,
        max_steps: int = -1,
    ) -> None:
        """Alias for the `step_until` method.

        Executes instructions of the process until the specified location is reached.

        Args:
            position (int | bytes): The location to reach.
            max_steps (int, optional): The maximum number of steps to execute. Defaults to -1.
        """
        self._internal_debugger.step_until(self, position, max_steps)

    def fin(self: ThreadContext, heuristic: str = "backtrace") -> None:
        """Alias for the `finish` method. Continues execution until the current function returns or the process stops.

        The command requires a heuristic to determine the end of the function. The available heuristics are:
        - `backtrace`: The debugger will place a breakpoint on the saved return address found on the stack and continue execution on all threads.
        - `step-mode`: The debugger will step on the specified thread until the current function returns. This will be slower.

        Args:
            heuristic (str, optional): The heuristic to use. Defaults to "backtrace".
        """
        self._internal_debugger.finish(self, heuristic)

    def ni(self: ThreadContext) -> None:
        """Alias for the `next` method. Executes the next instruction of the process. If the instruction is a call, the debugger will continue until the called function returns."""
        self._internal_debugger.next(self)

    def __repr__(self: ThreadContext) -> str:
        """Returns a string representation of the object."""
        repr_str = "ThreadContext()\n"
        repr_str += f"  Thread ID: {self.thread_id}\n"
        repr_str += f"  Process ID: {self.process_id}\n"
        repr_str += f"  Instruction Pointer: {self.instruction_pointer:#x}\n"
        repr_str += f"  Dead: {self.dead}"
        return repr_str

    def create_snapshot(self: ThreadContext, level: str = "base", name: str | None = None) -> ThreadSnapshot:
        """Create a snapshot of the current thread state.

        Snapshot levels:
        - base: Registers
        - writable: Registers, writable memory contents
        - full: Registers, all readable memory contents

        Args:
            level (str): The level of the snapshot.
            name (str, optional): The name of the snapshot. Defaults to None.

        Returns:
            ThreadSnapshot: The created snapshot.
        """
        self._internal_debugger._ensure_process_stopped()
        return ThreadSnapshot(self, level, name)

    def notify_snapshot_taken(self: ThreadContext) -> None:
        """Notify the thread that a snapshot has been taken."""
        self._snapshot_count += 1

_dead = False class-attribute instance-attribute

Whether the thread is dead.

_exit_code = None class-attribute instance-attribute

The thread's exit code.

_exit_signal = None class-attribute instance-attribute

The thread's exit signal.

_internal_debugger = provide_internal_debugger(self) class-attribute instance-attribute

The debugging context this thread belongs to.

_register_holder = registers class-attribute instance-attribute

The register holder object.

_signal_number = 0 class-attribute instance-attribute

The signal to forward to the thread.

_snapshot_count = 0 class-attribute instance-attribute

The number of snapshots taken.

_thread_id = thread_id instance-attribute

The thread's ID.

_zombie = False class-attribute instance-attribute

Whether the thread is a zombie.

dead property

Whether the thread is dead.

debugger property

The debugging context this thread belongs to.

exit_code property

The thread's exit code.

exit_signal property

The thread's exit signal.

instruction_pointer instance-attribute

The thread's instruction pointer.

mem property

Alias for the memory property.

Get the memory view of the process.

memory property

The memory view of the debugged process.

pid property

Alias for process_id property.

The process ID.

process_id property

The process ID.

regs = regs_class(thread_id, self._register_holder.provide_regs()) instance-attribute

The thread's registers.

running property

Whether the process is running.

saved_ip property

The return address of the current function.

signal property writable

The signal will be forwarded to the thread.

signal_number property

The signal number to forward to the thread.

syscall_arg0 instance-attribute

The thread's syscall argument 0.

syscall_arg1 instance-attribute

The thread's syscall argument 1.

syscall_arg2 instance-attribute

The thread's syscall argument 2.

syscall_arg3 instance-attribute

The thread's syscall argument 3.

syscall_arg4 instance-attribute

The thread's syscall argument 4.

syscall_arg5 instance-attribute

The thread's syscall argument 5.

syscall_number instance-attribute

The thread's syscall number.

syscall_return instance-attribute

The thread's syscall return value.

thread_id property

The thread ID.

tid property

The thread ID.

zombie property

Whether the thread is a zombie.

__init__(thread_id, registers)

Initializes the Thread Context.

Source code in libdebug/state/thread_context.py 
90
91
92
93
94
95
96
97
def __init__(self: ThreadContext, thread_id: int, registers: RegisterHolder) -> None:
    """Initializes the Thread Context."""
    self._internal_debugger = provide_internal_debugger(self)
    self._thread_id = thread_id
    self._register_holder = registers
    regs_class = self._register_holder.provide_regs_class()
    self.regs = regs_class(thread_id, self._register_holder.provide_regs())
    self._register_holder.apply_on_regs(self.regs, regs_class)

__repr__()

Returns a string representation of the object.

Source code in libdebug/state/thread_context.py 
351
352
353
354
355
356
357
358
def __repr__(self: ThreadContext) -> str:
    """Returns a string representation of the object."""
    repr_str = "ThreadContext()\n"
    repr_str += f"  Thread ID: {self.thread_id}\n"
    repr_str += f"  Process ID: {self.process_id}\n"
    repr_str += f"  Instruction Pointer: {self.instruction_pointer:#x}\n"
    repr_str += f"  Dead: {self.dead}"
    return repr_str

backtrace(as_symbols=False)

Returns the current backtrace of the thread.

Parameters:

Name Type Description Default
as_symbols bool

Whether to return the backtrace as symbols

 False
Source code in libdebug/state/thread_context.py 
223
224
225
226
227
228
229
230
231
232
233
234
235
236
def backtrace(self: ThreadContext, as_symbols: bool = False) -> list:
    """Returns the current backtrace of the thread.

    Args:
        as_symbols (bool, optional): Whether to return the backtrace as symbols
    """
    self._internal_debugger._ensure_process_stopped()
    stack_unwinder = stack_unwinding_provider(self._internal_debugger.arch)
    backtrace = stack_unwinder.unwind(self)
    if as_symbols:
        maps = self._internal_debugger.debugging_interface.get_maps()
        with extend_internal_debugger(self._internal_debugger):
            backtrace = [resolve_address_in_maps(x, maps) for x in backtrace]
    return backtrace

create_snapshot(level='base', name=None)

Create a snapshot of the current thread state.

Snapshot levels: - base: Registers - writable: Registers, writable memory contents - full: Registers, all readable memory contents

Parameters:

Name Type Description Default
level str

The level of the snapshot.

 'base'
name str

The name of the snapshot. Defaults to None.

 None

Returns:

Name Type Description
ThreadSnapshot ThreadSnapshot

The created snapshot.
Source code in libdebug/state/thread_context.py 
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
def create_snapshot(self: ThreadContext, level: str = "base", name: str | None = None) -> ThreadSnapshot:
    """Create a snapshot of the current thread state.

    Snapshot levels:
    - base: Registers
    - writable: Registers, writable memory contents
    - full: Registers, all readable memory contents

    Args:
        level (str): The level of the snapshot.
        name (str, optional): The name of the snapshot. Defaults to None.

    Returns:
        ThreadSnapshot: The created snapshot.
    """
    self._internal_debugger._ensure_process_stopped()
    return ThreadSnapshot(self, level, name)

fin(heuristic='backtrace')

Alias for the finish method. Continues execution until the current function returns or the process stops.

The command requires a heuristic to determine the end of the function. The available heuristics are: - backtrace: The debugger will place a breakpoint on the saved return address found on the stack and continue execution on all threads. - step-mode: The debugger will step on the specified thread until the current function returns. This will be slower.

Parameters:

Name Type Description Default
heuristic str

The heuristic to use. Defaults to "backtrace".

 'backtrace'
Source code in libdebug/state/thread_context.py 
335
336
337
338
339
340
341
342
343
344
345
def fin(self: ThreadContext, heuristic: str = "backtrace") -> None:
    """Alias for the `finish` method. Continues execution until the current function returns or the process stops.

    The command requires a heuristic to determine the end of the function. The available heuristics are:
    - `backtrace`: The debugger will place a breakpoint on the saved return address found on the stack and continue execution on all threads.
    - `step-mode`: The debugger will step on the specified thread until the current function returns. This will be slower.

    Args:
        heuristic (str, optional): The heuristic to use. Defaults to "backtrace".
    """
    self._internal_debugger.finish(self, heuristic)

finish(heuristic='backtrace')

Continues execution until the current function returns or the process stops.

The command requires a heuristic to determine the end of the function. The available heuristics are: - backtrace: The debugger will place a breakpoint on the saved return address found on the stack and continue execution on all threads. - step-mode: The debugger will step on the specified thread until the current function returns. This will be slower.

Parameters:

Name Type Description Default
heuristic str

The heuristic to use. Defaults to "backtrace".

 'backtrace'
Source code in libdebug/state/thread_context.py 
297
298
299
300
301
302
303
304
305
306
307
def finish(self: ThreadContext, heuristic: str = "backtrace") -> None:
    """Continues execution until the current function returns or the process stops.

    The command requires a heuristic to determine the end of the function. The available heuristics are:
    - `backtrace`: The debugger will place a breakpoint on the saved return address found on the stack and continue execution on all threads.
    - `step-mode`: The debugger will step on the specified thread until the current function returns. This will be slower.

    Args:
        heuristic (str, optional): The heuristic to use. Defaults to "backtrace".
    """
    self._internal_debugger.finish(self, heuristic=heuristic)

next()

Executes the next instruction of the process. If the instruction is a call, the debugger will continue until the called function returns.

Source code in libdebug/state/thread_context.py 
309
310
311
def next(self: ThreadContext) -> None:
    """Executes the next instruction of the process. If the instruction is a call, the debugger will continue until the called function returns."""
    self._internal_debugger.next(self)

ni()

Alias for the next method. Executes the next instruction of the process. If the instruction is a call, the debugger will continue until the called function returns.

Source code in libdebug/state/thread_context.py 
347
348
349
def ni(self: ThreadContext) -> None:
    """Alias for the `next` method. Executes the next instruction of the process. If the instruction is a call, the debugger will continue until the called function returns."""
    self._internal_debugger.next(self)

notify_snapshot_taken()

Notify the thread that a snapshot has been taken.

Source code in libdebug/state/thread_context.py 
378
379
380
def notify_snapshot_taken(self: ThreadContext) -> None:
    """Notify the thread that a snapshot has been taken."""
    self._snapshot_count += 1

pprint_backtrace()

Pretty prints the current backtrace of the thread.

Source code in libdebug/state/thread_context.py 
238
239
240
241
242
243
244
def pprint_backtrace(self: ThreadContext) -> None:
    """Pretty prints the current backtrace of the thread."""
    self._internal_debugger._ensure_process_stopped()
    stack_unwinder = stack_unwinding_provider(self._internal_debugger.arch)
    backtrace = stack_unwinder.unwind(self)
    maps = self._internal_debugger.debugging_interface.get_maps()
    pprint_backtrace_util(backtrace, maps, self._internal_debugger.symbols)

pprint_registers()

Pretty prints the thread's registers.

Source code in libdebug/state/thread_context.py 
246
247
248
249
250
251
252
def pprint_registers(self: ThreadContext) -> None:
    """Pretty prints the thread's registers."""
    pprint_registers_util(
        self.regs,
        self._internal_debugger.maps,
        self._register_holder.provide_regs(),
    )

pprint_registers_all()

Pretty prints all the thread's registers.

Source code in libdebug/state/thread_context.py 
261
262
263
264
265
266
267
268
269
def pprint_registers_all(self: ThreadContext) -> None:
    """Pretty prints all the thread's registers."""
    pprint_registers_all_util(
        self.regs,
        self._internal_debugger.maps,
        self._register_holder.provide_regs(),
        self._register_holder.provide_special_regs(),
        self._register_holder.provide_vector_fp_regs(),
    )

pprint_regs()

Alias for the pprint_registers method.

Pretty prints the thread's registers.

Source code in libdebug/state/thread_context.py 
254
255
256
257
258
259
def pprint_regs(self: ThreadContext) -> None:
    """Alias for the `pprint_registers` method.

    Pretty prints the thread's registers.
    """
    self.pprint_registers()

pprint_regs_all()

Alias for the pprint_registers_all method.

Pretty prints all the thread's registers.

Source code in libdebug/state/thread_context.py 
271
272
273
274
275
276
def pprint_regs_all(self: ThreadContext) -> None:
    """Alias for the `pprint_registers_all` method.

    Pretty prints all the thread's registers.
    """
    self.pprint_registers_all()

set_as_dead()

Set the thread as dead.

Source code in libdebug/state/thread_context.py 
 99
100
101
def set_as_dead(self: ThreadContext) -> None:
    """Set the thread as dead."""
    self._dead = True

si()

Alias for the step method.

Executes a single instruction of the process.

Source code in libdebug/state/thread_context.py 
313
314
315
316
317
318
def si(self: ThreadContext) -> None:
    """Alias for the `step` method.

    Executes a single instruction of the process.
    """
    self._internal_debugger.step(self)

step()

Executes a single instruction of the process.

Source code in libdebug/state/thread_context.py 
278
279
280
def step(self: ThreadContext) -> None:
    """Executes a single instruction of the process."""
    self._internal_debugger.step(self)

step_until(position, max_steps=-1, file='hybrid')

Executes instructions of the process until the specified location is reached.

Parameters:

Name Type Description Default
position int | bytes

The location to reach.

 required
max_steps int

The maximum number of steps to execute. Defaults to -1.

 -1
file str

The user-defined backing file to resolve the address in. Defaults to "hybrid" (libdebug will first try to solve the address as an absolute address, then as a relative address w.r.t. the "binary" map file).

 'hybrid'
Source code in libdebug/state/thread_context.py 
282
283
284
285
286
287
288
289
290
291
292
293
294
295
def step_until(
    self: ThreadContext,
    position: int | str,
    max_steps: int = -1,
    file: str = "hybrid",
) -> None:
    """Executes instructions of the process until the specified location is reached.

    Args:
        position (int | bytes): The location to reach.
        max_steps (int, optional): The maximum number of steps to execute. Defaults to -1.
        file (str, optional): The user-defined backing file to resolve the address in. Defaults to "hybrid" (libdebug will first try to solve the address as an absolute address, then as a relative address w.r.t. the "binary" map file).
    """
    self._internal_debugger.step_until(self, position, max_steps, file)

su(position, max_steps=-1)

Alias for the step_until method.

Executes instructions of the process until the specified location is reached.

Parameters:

Name Type Description Default
position int | bytes

The location to reach.

 required
max_steps int

The maximum number of steps to execute. Defaults to -1.

 -1
Source code in libdebug/state/thread_context.py 
320
321
322
323
324
325
326
327
328
329
330
331
332
333
def su(
    self: ThreadContext,
    position: int | str,
    max_steps: int = -1,
) -> None:
    """Alias for the `step_until` method.

    Executes instructions of the process until the specified location is reached.

    Args:
        position (int | bytes): The location to reach.
        max_steps (int, optional): The maximum number of steps to execute. Defaults to -1.
    """
    self._internal_debugger.step_until(self, position, max_steps)