vagd.gdb

Submodules

Attributes

`PYTHONDIR`
`STDOUT`
`STDERR`
`STDLOG`
`_ValueOrNative`
`_ValueOrInt`
`TYPE_CODE_PTR`
`TYPE_CODE_ARRAY`
`TYPE_CODE_STRUCT`
`TYPE_CODE_UNION`
`TYPE_CODE_ENUM`
`TYPE_CODE_FLAGS`
`TYPE_CODE_FUNC`
`TYPE_CODE_INT`
`TYPE_CODE_FLT`
`TYPE_CODE_VOID`
`TYPE_CODE_SET`
`TYPE_CODE_RANGE`
`TYPE_CODE_STRING`
`TYPE_CODE_BITSTRING`
`TYPE_CODE_ERROR`
`TYPE_CODE_METHOD`
`TYPE_CODE_METHODPTR`
`TYPE_CODE_MEMBERPTR`
`TYPE_CODE_REF`
`TYPE_CODE_RVALUE_REF`
`TYPE_CODE_CHAR`
`TYPE_CODE_BOOL`
`TYPE_CODE_COMPLEX`
`TYPE_CODE_TYPEDEF`
`TYPE_CODE_NAMESPACE`
`TYPE_CODE_DECFLOAT`
`TYPE_CODE_INTERNAL_FUNCTION`
`_PrettyPrinterLookupFunction`
`pretty_printers`
`_BufferType`
`COMMAND_NONE`
`COMMAND_RUNNING`
`COMMAND_DATA`
`COMMAND_STACK`
`COMMAND_FILES`
`COMMAND_SUPPORT`
`COMMAND_STATUS`
`COMMAND_BREAKPOINTS`
`COMMAND_TRACEPOINTS`
`COMMAND_TUI`
`COMMAND_USER`
`COMMAND_OBSCURE`
`COMMAND_MAINTENANCE`
`COMPLETE_NONE`
`COMPLETE_FILENAME`
`COMPLETE_LOCATION`
`COMPLETE_COMMAND`
`COMPLETE_SYMBOL`
`COMPLETE_EXPRESSION`
`PARAM_BOOLEAN`
`PARAM_AUTO_BOOLEAN`
`PARAM_UINTEGER`
`PARAM_INTEGER`
`PARAM_STRING`
`PARAM_STRING_NOESCAPE`
`PARAM_OPTIONAL_FILENAME`
`PARAM_FILENAME`
`PARAM_ZINTEGER`
`PARAM_ZUINTEGER`
`PARAM_ZUINTEGER_UNLIMITED`
`PARAM_ENUM`
`NORMAL_FRAME`
`INLINE_FRAME`
`TAILCALL_FRAME`
`SIGTRAMP_FRAME`
`ARCH_FRAME`
`SENTINEL_FRAME`
`FRAME_UNWIND_NO_REASON`
`FRAME_UNWIND_NULL_ID`
`FRAME_UNWIND_OUTERMOST`
`FRAME_UNWIND_UNAVAILABLE`
`FRAME_UNWIND_INNER_ID`
`FRAME_UNWIND_SAME_ID`
`FRAME_UNWIND_NO_SAVED_PC`
`FRAME_UNWIND_MEMORY_ERROR`
`FRAME_UNWIND_FIRST_ERROR`
`SYMBOL_UNDEF_DOMAIN`
`SYMBOL_VAR_DOMAIN`
`SYMBOL_STRUCT_DOMAIN`
`SYMBOL_LABEL_DOMAIN`
`SYMBOL_MODULE_DOMAIN`
`SYMBOL_COMMON_BLOCK_DOMAIN`
`SYMBOL_LOC_UNDEF`
`SYMBOL_LOC_CONST`
`SYMBOL_LOC_STATIC`
`SYMBOL_LOC_REGISTER`
`SYMBOL_LOC_ARG`
`SYMBOL_LOC_REF_ARG`
`SYMBOL_LOC_REGPARM_ADDR`
`SYMBOL_LOC_LOCAL`
`SYMBOL_LOC_TYPEDEF`
`SYMBOL_LOC_LABEL`
`SYMBOL_LOC_BLOCK`
`SYMBOL_LOC_CONST_BYTES`
`SYMBOL_LOC_UNRESOLVED`
`SYMBOL_LOC_OPTIMIZED_OUT`
`SYMBOL_LOC_COMPUTED`
`SYMBOL_LOC_COMMON_BLOCK`
`BP_BREAKPOINT`
`BP_HARDWARE_BREAKPOINT`
`BP_WATCHPOINT`
`BP_HARDWARE_WATCHPOINT`
`BP_READ_WATCHPOINT`
`BP_ACCESS_WATCHPOINT`
`BP_CATCHPOINT`
`WP_READ`
`WP_WRITE`
`WP_ACCESS`

Exceptions

`error`	Unspecified run-time error.
`MemoryError`	Unspecified run-time error.
`GdbError`	Common base class for all non-exit exceptions.

Classes

`GDB`
`Value`
`Type`
`Field`
`_PrettyPrinter`	Base class for protocol classes.
`_FrameFilter`	Base class for protocol classes.
`_SymValueWrapper`	Base class for protocol classes.
`_FrameDecorator`	Base class for protocol classes.
`PendingFrame`
`UnwindInfo`
`Unwinder`
`Inferior`
`InferiorThread`
`Record`
`Instruction`
`RecordInstruction`
`RecordGap`
`RecordFunctionSegment`
`Command`
`MICommand`
`Parameter`
`Function`
`Progspace`
`Objfile`
`Frame`
`Block`
`BlockIterator`
`Symbol`
`Symtab_and_line`
`Symtab`
`LineTableEntry`
`LineTable`
`Breakpoint`
`FinishBreakpoint`
`LazyString`
`Architecture`
`RegisterDescriptor`
`RegisterDescriptorIterator`
`RegisterGroup`
`RegisterGroupsIterator`
`TargetConnection`
`RemoteTargetConnection`
`TuiWindow`
`_Window`	Base class for protocol classes.

Functions

`lookup_type`(→ Type)
`default_visualizer`(→ _PrettyPrinter \| None)
`inferiors`(→ tuple[Inferior, Ellipsis])
`selected_inferior`(→ Inferior)
`selected_thread`(→ InferiorThread)
`start_recording`(→ Record)
`current_recording`(→ Record \| None)
`stop_recording`(→ None)
`string_to_argv`(→ list[str])
`current_progspace`(→ Progspace \| None)
`progspaces`(→ collections.abc.Sequence[Progspace])
`current_objfile`(→ Objfile \| None)
`objfiles`(→ list[Objfile])
`lookup_objfile`(→ Objfile \| None)
`selected_frame`(→ Frame)
`newest_frame`(→ Frame)
`frame_stop_reason_string`(→ str)
`invalidate_cached_frames`(→ None)
`block_for_pc`(→ Block \| None)
`lookup_symbol`(→ tuple[Symbol \| None, bool])
`lookup_global_symbol`(→ Symbol \| None)
`lookup_static_symbol`(→ Symbol \| None)
`lookup_static_symbols`(→ list[Symbol])
`register_window_type`(→ None)

Package Contents

vagd.gdb.PYTHONDIR: str

vagd.gdb.STDOUT: int

vagd.gdb.STDERR: int

vagd.gdb.STDLOG: int

class vagd.gdb.GDB

execute(command: str, from_tty: bool = ..., to_string: bool = ...) → str | None

breakpoints() → collections.abc.Sequence[Breakpoint]

rbreak(regex: str, minsyms: bool = ..., throttle: int = ..., symtabs: collections.abc.Iterator[Symtab] = ...) → list[Breakpoint]

parameter(__parameter: str) → bool | int | str | None

set_parameter(name: str, value: bool | int | str | None) → None

with_parameter(name: str, value: bool | int | str | None) → contextlib.AbstractContextManager[None]

history(__number: int) → Value

add_history(__value: Value) → int

history_count() → int

convenience_variable(__name: str) → Value | None

set_convenience_variable(__name: str, __value: _ValueOrNative | None) → None

parse_and_eval(__expression: str) → Value

find_pc_line(pc: int | Value) → Symtab_and_line

post_event(__event: collections.abc.Callable[[], object]) → None

write(string: str, stream: int = ...) → None

flush(stream: int = ...) → None

target_charset() → str

target_wide_charset() → str

host_charset() → str

solib_name(address: int) → str | None

decode_line(__expression: str = ...) → tuple[str | None, tuple[Symtab_and_line, Ellipsis] | None]

prompt_hook(current_prompt: str) → str

architecture_names() → list[str]

connections() → list[TargetConnection]

exception vagd.gdb.error

Bases: RuntimeError

Unspecified run-time error.

exception vagd.gdb.MemoryError

Bases: error

Unspecified run-time error.

exception vagd.gdb.GdbError

Bases: Exception

Common base class for all non-exit exceptions.

type vagd.gdb._ValueOrNative = bool | float | str | Value

type vagd.gdb._ValueOrInt = Value | int

class vagd.gdb.Value(val: _ValueOrNative)

address: Value

is_optimized_out: bool

type: Type

dynamic_type: Type

is_lazy: bool

__index__() → int

__int__() → int

__float__() → float

__add__(other: _ValueOrInt) → Value

__sub__(other: _ValueOrInt) → Value

__mul__(other: _ValueOrInt) → Value

__truediv__(other: _ValueOrInt) → Value

__mod__(other: _ValueOrInt) → Value

__and__(other: _ValueOrInt) → Value

__or__(other: _ValueOrInt) → Value

__xor__(other: _ValueOrInt) → Value

__lshift__(other: _ValueOrInt) → Value

__rshift__(other: _ValueOrInt) → Value

__eq__(other: _ValueOrInt) → bool

__ne__(other: _ValueOrInt) → bool

__lt__(other: _ValueOrInt) → bool

__le__(other: _ValueOrInt) → bool

__gt__(other: _ValueOrInt) → bool

__ge__(other: _ValueOrInt) → bool

__getitem__(key: int | str | Field) → Value

__call__(*args: _ValueOrNative) → Value

cast(type: Type) → Value

dereference() → Value

referenced_value() → Value

reference_value() → Value

const_value() → Value

dynamic_cast(type: Type) → Value

reinterpret_cast(type: Type) → Value

format_string(raw: bool = ..., pretty_arrays: bool = ..., pretty_structs: bool = ..., array_indexes: bool = ..., symbols: bool = ..., unions: bool = ..., address: bool = ..., deref_refs: bool = ..., actual_objects: bool = ..., static_members: bool = ..., max_elements: int = ..., max_depth: int = ..., repeat_threshold: int = ..., format: str = ...) → str

string(encoding: str = ..., errors: str = ..., length: int = ...) → str

lazy_string(encoding: str = ..., length: int = ...) → LazyString

fetch_lazy() → None

vagd.gdb.lookup_type(name: str, block: Block = ...) → Type

class vagd.gdb.Type

alignof: int

code: int

dynamic: bool

name: str

sizeof: int

tag: str | None

objfile: Objfile | None

fields() → list[Field]

array(n1: int | Value, n2: int | Value = ...) → Type

vector(n1: int, n2: int = ...) → Type

const() → Type

volatile() → Type

unqualified() → Type

range() → tuple[int, int]

reference() → Type

pointer() → Type

strip_typedefs() → Type

target() → Type

template_argument(n: int, block: Block = ...) → Type

optimized_out() → Value

class vagd.gdb.Field

bitpos: int

enumval: int

name: str | None

artificial: bool

is_base_class: bool

bitsize: int

type: Type

parent_type: Type

vagd.gdb.TYPE_CODE_PTR: int

vagd.gdb.TYPE_CODE_ARRAY: int

vagd.gdb.TYPE_CODE_STRUCT: int

vagd.gdb.TYPE_CODE_UNION: int

vagd.gdb.TYPE_CODE_ENUM: int

vagd.gdb.TYPE_CODE_FLAGS: int

vagd.gdb.TYPE_CODE_FUNC: int

vagd.gdb.TYPE_CODE_INT: int

vagd.gdb.TYPE_CODE_FLT: int

vagd.gdb.TYPE_CODE_VOID: int

vagd.gdb.TYPE_CODE_SET: int

vagd.gdb.TYPE_CODE_RANGE: int

vagd.gdb.TYPE_CODE_STRING: int

vagd.gdb.TYPE_CODE_BITSTRING: int

vagd.gdb.TYPE_CODE_ERROR: int

vagd.gdb.TYPE_CODE_METHOD: int

vagd.gdb.TYPE_CODE_METHODPTR: int

vagd.gdb.TYPE_CODE_MEMBERPTR: int

vagd.gdb.TYPE_CODE_REF: int

vagd.gdb.TYPE_CODE_RVALUE_REF: int

vagd.gdb.TYPE_CODE_CHAR: int

vagd.gdb.TYPE_CODE_BOOL: int

vagd.gdb.TYPE_CODE_COMPLEX: int

vagd.gdb.TYPE_CODE_TYPEDEF: int

vagd.gdb.TYPE_CODE_NAMESPACE: int

vagd.gdb.TYPE_CODE_DECFLOAT: int

vagd.gdb.TYPE_CODE_INTERNAL_FUNCTION: int

class vagd.gdb._PrettyPrinter

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

to_string() → str | LazyString

type vagd.gdb._PrettyPrinterLookupFunction = Callable[[Value], _PrettyPrinter | None]

vagd.gdb.default_visualizer(__value: Value) → _PrettyPrinter | None

vagd.gdb.pretty_printers: list[_PrettyPrinterLookupFunction]

class vagd.gdb._FrameFilter

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

name: str

enabled: bool

priority: int

filter(iterator: collections.abc.Iterator[_FrameDecorator]) → collections.abc.Iterator[_FrameDecorator]

class vagd.gdb._SymValueWrapper

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

symbol() → Symbol | str

value() → _ValueOrNative | None

class vagd.gdb._FrameDecorator

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

elided() → collections.abc.Iterator[Frame] | None

function() → str | None

address() → int | None

filename() → str | None

line() → int | None

frame_args() → collections.abc.Iterator[_SymValueWrapper] | None

frame_locals() → collections.abc.Iterator[_SymValueWrapper] | None

inferior_frame() → Frame

class vagd.gdb.PendingFrame

read_register(__reg: str | RegisterDescriptor | int) → Value

create_unwind_info(__frame_id: object) → UnwindInfo

architecture() → Architecture

level() → int

class vagd.gdb.UnwindInfo

add_saved_register(__reg: str | RegisterDescriptor | int, __value: Value) → None

class vagd.gdb.Unwinder

name: str

enabled: bool

__call__(pending_frame: Frame) → UnwindInfo | None

vagd.gdb.inferiors() → tuple[Inferior, Ellipsis]

vagd.gdb.selected_inferior() → Inferior

type vagd.gdb._BufferType = _typeshed.ReadableBuffer

class vagd.gdb.Inferior

num: int

connection_num: int

pid: int

was_attached: bool

progspace: Progspace

is_valid() → bool

threads() → tuple[InferiorThread, Ellipsis]

architecture() → Architecture

read_memory(address: _ValueOrInt, length: int) → memoryview

write_memory(address: _ValueOrInt, buffer: _BufferType, length: int = ...) → memoryview

search_memory(address: _ValueOrInt, length: int, pattern: _BufferType) → int | None

thread_from_handle(handle: Value) → InferiorThread

vagd.gdb.selected_thread() → InferiorThread

class vagd.gdb.InferiorThread

name: str | None

num: int

global_num: int

ptid: tuple[int, int, int]

inferior: Inferior

is_valid() → bool

switch() → None

is_stopped() → bool

is_running() → bool

is_exited() → bool

handle() → bytes

vagd.gdb.start_recording(__method: str = ..., __format: str = ...) → Record

vagd.gdb.current_recording() → Record | None

vagd.gdb.stop_recording() → None

class vagd.gdb.Record

method: str

format: str | None

begin: Instruction

end: Instruction

replay_position: Instruction | None

instruction_history: list[Instruction]

function_call_history: list[RecordFunctionSegment]

goto(__instruction: Instruction) → None

class vagd.gdb.Instruction

pc: int

data: memoryview

decoded: str

size: int

class vagd.gdb.RecordInstruction

Bases: Instruction

number: int

sal: Symtab_and_line | None

is_speculative: bool

class vagd.gdb.RecordGap

Bases: Instruction

number: int

error_code: int

error_string: str

class vagd.gdb.RecordFunctionSegment

number: int

symbol: Symbol | None

level: int | None

instructions: list[RecordInstruction | RecordGap]

up: RecordFunctionSegment | None

prev: RecordFunctionSegment | None

next: RecordFunctionSegment | None

class vagd.gdb.Command(name: str, command_class: int, completer_class: int = ..., prefix: bool = ...)

dont_repeat() → None

invoke(argument: str, from_tty: bool) → None

complete(text: str, word: str) → object

vagd.gdb.string_to_argv(__argv: str) → list[str]

vagd.gdb.COMMAND_NONE: int

vagd.gdb.COMMAND_RUNNING: int

vagd.gdb.COMMAND_DATA: int

vagd.gdb.COMMAND_STACK: int

vagd.gdb.COMMAND_FILES: int

vagd.gdb.COMMAND_SUPPORT: int

vagd.gdb.COMMAND_STATUS: int

vagd.gdb.COMMAND_BREAKPOINTS: int

vagd.gdb.COMMAND_TRACEPOINTS: int

vagd.gdb.COMMAND_TUI: int

vagd.gdb.COMMAND_USER: int

vagd.gdb.COMMAND_OBSCURE: int

vagd.gdb.COMMAND_MAINTENANCE: int

vagd.gdb.COMPLETE_NONE: int

vagd.gdb.COMPLETE_FILENAME: int

vagd.gdb.COMPLETE_LOCATION: int

vagd.gdb.COMPLETE_COMMAND: int

vagd.gdb.COMPLETE_SYMBOL: int

vagd.gdb.COMPLETE_EXPRESSION: int

class vagd.gdb.MICommand(name: str)

name: str

installed: bool

invoke(arguments: list[str]) → dict[str, object] | None

class vagd.gdb.Parameter(name: str, command_class: int, parameter_class: int, enum_sequence: collections.abc.Sequence[str] = ...)

set_doc: str

show_doc: str

value: object

get_set_string() → str

get_show_string(svalue: str) → str

vagd.gdb.PARAM_BOOLEAN: int

vagd.gdb.PARAM_AUTO_BOOLEAN: int

vagd.gdb.PARAM_UINTEGER: int

vagd.gdb.PARAM_INTEGER: int

vagd.gdb.PARAM_STRING: int

vagd.gdb.PARAM_STRING_NOESCAPE: int

vagd.gdb.PARAM_OPTIONAL_FILENAME: int

vagd.gdb.PARAM_FILENAME: int

vagd.gdb.PARAM_ZINTEGER: int

vagd.gdb.PARAM_ZUINTEGER: int

vagd.gdb.PARAM_ZUINTEGER_UNLIMITED: int

vagd.gdb.PARAM_ENUM: int

class vagd.gdb.Function(name: str)

invoke(*args: Value) → _ValueOrNative

vagd.gdb.current_progspace() → Progspace | None

vagd.gdb.progspaces() → collections.abc.Sequence[Progspace]

class vagd.gdb.Progspace

filename: str

pretty_printers: list[_PrettyPrinterLookupFunction]

type_printers: list[gdb.types._TypePrinter]

frame_filters: list[_FrameFilter]

block_for_pc(__pc: int) → Block | None

find_pc_line(__pc: int) → Symtab_and_line

is_valid() → bool

objfiles() → collections.abc.Sequence[Objfile]

solib_name(__address: int) → str | None

vagd.gdb.current_objfile() → Objfile | None

vagd.gdb.objfiles() → list[Objfile]

vagd.gdb.lookup_objfile(name: str, by_build_id: bool = ...) → Objfile | None

class vagd.gdb.Objfile

filename: str | None

username: str | None

owner: Objfile | None

build_id: str | None

progspace: Progspace

pretty_printers: list[_PrettyPrinterLookupFunction]

type_printers: list[gdb.types._TypePrinter]

frame_filters: list[_FrameFilter]

is_valid() → bool

add_separate_debug_file(file: str) → None

lookup_global_symbol(name: str, domain: int = ...) → Symbol | None

lookup_static_method(name: str, domain: int = ...) → Symbol | None

vagd.gdb.selected_frame() → Frame

vagd.gdb.newest_frame() → Frame

vagd.gdb.frame_stop_reason_string(__code: int) → str

vagd.gdb.invalidate_cached_frames() → None

vagd.gdb.NORMAL_FRAME: int

vagd.gdb.INLINE_FRAME: int

vagd.gdb.TAILCALL_FRAME: int

vagd.gdb.SIGTRAMP_FRAME: int

vagd.gdb.ARCH_FRAME: int

vagd.gdb.SENTINEL_FRAME: int

vagd.gdb.FRAME_UNWIND_NO_REASON: int

vagd.gdb.FRAME_UNWIND_NULL_ID: int

vagd.gdb.FRAME_UNWIND_OUTERMOST: int

vagd.gdb.FRAME_UNWIND_UNAVAILABLE: int

vagd.gdb.FRAME_UNWIND_INNER_ID: int

vagd.gdb.FRAME_UNWIND_SAME_ID: int

vagd.gdb.FRAME_UNWIND_NO_SAVED_PC: int

vagd.gdb.FRAME_UNWIND_MEMORY_ERROR: int

vagd.gdb.FRAME_UNWIND_FIRST_ERROR: int

class vagd.gdb.Frame

is_valid() → bool

name() → str | None

architecture() → Architecture

type() → int

unwind_stop_reason() → int

pc() → Value

block() → Block

function() → Symbol

older() → Frame | None

newer() → Frame | None

find_sal() → Symtab_and_line

read_register(__register: str | RegisterDescriptor | int) → Value

read_var(__variable: str | Symbol, block: Block | None = ...) → Value

select() → None

level() → int

vagd.gdb.block_for_pc(pc: int) → Block | None

class vagd.gdb.Block

start: int

end: int

function: Symbol | None

superblock: Block | None

global_block: Block

static_block: Block | None

is_global: bool

is_static: bool

is_valid() → bool

__iter__() → BlockIterator

class vagd.gdb.BlockIterator

is_valid() → bool

__iter__() → _typeshed.Self

__next__() → Symbol

vagd.gdb.lookup_symbol(name: str, block: Block | None = ..., domain: int = ...) → tuple[Symbol | None, bool]

vagd.gdb.lookup_global_symbol(name: str, domain: int = ...) → Symbol | None

vagd.gdb.lookup_static_symbol(name: str, domain: int = ...) → Symbol | None

vagd.gdb.lookup_static_symbols(name: str, domain: int = ...) → list[Symbol]

class vagd.gdb.Symbol

type: Type | None

symtab: Symtab

line: int

name: str

linkage_name: str

print_name: str

addr_class: int

needs_frame: bool

is_argument: bool

is_constant: bool

is_function: bool

is_variable: bool

is_valid() → bool

value(__frame: Frame = ...) → Value

vagd.gdb.SYMBOL_UNDEF_DOMAIN: int

vagd.gdb.SYMBOL_VAR_DOMAIN: int

vagd.gdb.SYMBOL_STRUCT_DOMAIN: int

vagd.gdb.SYMBOL_LABEL_DOMAIN: int

vagd.gdb.SYMBOL_MODULE_DOMAIN: int

vagd.gdb.SYMBOL_COMMON_BLOCK_DOMAIN: int

vagd.gdb.SYMBOL_LOC_UNDEF: int

vagd.gdb.SYMBOL_LOC_CONST: int

vagd.gdb.SYMBOL_LOC_STATIC: int

vagd.gdb.SYMBOL_LOC_REGISTER: int

vagd.gdb.SYMBOL_LOC_ARG: int

vagd.gdb.SYMBOL_LOC_REF_ARG: int

vagd.gdb.SYMBOL_LOC_REGPARM_ADDR: int

vagd.gdb.SYMBOL_LOC_LOCAL: int

vagd.gdb.SYMBOL_LOC_TYPEDEF: int

vagd.gdb.SYMBOL_LOC_LABEL: int

vagd.gdb.SYMBOL_LOC_BLOCK: int

vagd.gdb.SYMBOL_LOC_CONST_BYTES: int

vagd.gdb.SYMBOL_LOC_UNRESOLVED: int

vagd.gdb.SYMBOL_LOC_OPTIMIZED_OUT: int

vagd.gdb.SYMBOL_LOC_COMPUTED: int

vagd.gdb.SYMBOL_LOC_COMMON_BLOCK: int

class vagd.gdb.Symtab_and_line

symtab: Symtab

pc: int

last: int

line: int

is_valid() → bool

class vagd.gdb.Symtab

filename: str

objfile: Objfile

producer: str

is_valid() → bool

fullname() → str

global_block() → Block

static_block() → Block

linetable() → LineTable

class vagd.gdb.LineTableEntry

line: int

pc: int

class vagd.gdb.LineTable

Bases: collections.abc.Iterator[LineTableEntry]

__iter__() → _typeshed.Self

__next__() → LineTableEntry: Return the next item from the iterator. When exhausted, raise StopIteration

line(__line: int) → tuple[LineTableEntry, Ellipsis]

has_line(__line: int) → bool

source_lnes() → list[int]

class vagd.gdb.Breakpoint(spec: str, type: int = ..., wp_class: int = ..., internal: bool = ..., temporary: bool = ..., qualified: bool = ...)

class vagd.gdb.Breakpoint(source: str = ..., function: str = ..., label: str = ..., line: int = ..., internal: bool = ..., temporary: bool = ..., qualified: bool = ...)

stop() → bool

is_valid() → bool

delete() → None

enabled: bool

silent: bool

pending: bool

thread: int | None

task: str | None

ignore_count: int

number: int

type: int

visible: bool

temporary: bool

hit_count: int

location: str | None

expression: str | None

condition: str | None

commands: str | None

vagd.gdb.BP_BREAKPOINT: int

vagd.gdb.BP_HARDWARE_BREAKPOINT: int

vagd.gdb.BP_WATCHPOINT: int

vagd.gdb.BP_HARDWARE_WATCHPOINT: int

vagd.gdb.BP_READ_WATCHPOINT: int

vagd.gdb.BP_ACCESS_WATCHPOINT: int

vagd.gdb.BP_CATCHPOINT: int

vagd.gdb.WP_READ: int

vagd.gdb.WP_WRITE: int

vagd.gdb.WP_ACCESS: int

class vagd.gdb.FinishBreakpoint(frame: Frame = ..., internal: bool = ...)

Bases: Breakpoint

return_value: Value | None

out_of_scope() → None

class vagd.gdb.LazyString

value() → Value

address: Value

length: int

encoding: str

type: Type

class vagd.gdb.Architecture

name() → str

disassemble(start_pc: int, end_pc: int = ..., count: int = ...) → list[dict[str, object]]

integer_type(size: int, signed: bool = ...) → Type

registers(reggroup: str = ...) → RegisterDescriptorIterator

register_groups() → RegisterGroupsIterator

class vagd.gdb.RegisterDescriptor

name: str

class vagd.gdb.RegisterDescriptorIterator

Bases: collections.abc.Iterator[RegisterDescriptor]

__next__() → RegisterDescriptor: Return the next item from the iterator. When exhausted, raise StopIteration

find(name: str) → RegisterDescriptor | None

class vagd.gdb.RegisterGroup

name: str

class vagd.gdb.RegisterGroupsIterator

Bases: collections.abc.Iterator[RegisterGroup]

__next__() → RegisterGroup: Return the next item from the iterator. When exhausted, raise StopIteration

class vagd.gdb.TargetConnection

is_valid() → bool

num: int

type: str

description: str

details: str | None

class vagd.gdb.RemoteTargetConnection

Bases: TargetConnection

send_packet(packet: str | bytes) → bytes

vagd.gdb.register_window_type(name: str, factory: collections.abc.Callable[[TuiWindow], _Window]) → None

class vagd.gdb.TuiWindow

width: int

height: int

title: str

is_valid() → bool

erase() → None

write(__string: str, __full_window: bool = ...) → None

class vagd.gdb._Window

Bases: Protocol

Base class for protocol classes.

Protocol classes are defined as:

class Proto(Protocol):
    def meth(self) -> int:
        ...

Such classes are primarily used with static type checkers that recognize structural subtyping (static duck-typing).

For example:

class C:
    def meth(self) -> int:
        return 0

def func(x: Proto) -> int:
    return x.meth()

func(C())  # Passes static type check

See PEP 544 for details. Protocol classes decorated with @typing.runtime_checkable act as simple-minded runtime protocols that check only the presence of given attributes, ignoring their type signatures. Protocol classes can be generic, they are defined as:

class GenProto[T](Protocol):
    def meth(self) -> T:
        ...

close() → None

render() → None

hscroll(num: int) → None

vscroll(num: int) → None

click(x: int, y: int, button: int) → None