SYMBOL INDEX (1414 symbols across 88 files)

FILE: gef.py
  function http_get (line 93) | def http_get(url: str) -> bytes | None:
  function update_gef (line 103) | def update_gef(argv: list[str]) -> int:
  function reset_all_caches (line 154) | def reset_all_caches() -> None:
  function reset (line 167) | def reset() -> None:
  function highlight_text (line 184) | def highlight_text(text: str) -> str:
  function gef_print (line 219) | def gef_print(*args: str, end="\n", sep=" ", **kwargs: Any) -> None:
  function bufferize (line 230) | def bufferize(f: Callable) -> Callable:
  class ValidationError (line 276) | class ValidationError(Exception): pass
  class ObsoleteException (line 282) | class ObsoleteException(Exception): pass
  class AlreadyRegisteredException (line 284) | class AlreadyRegisteredException(Exception): pass
  function p8 (line 286) | def p8(x: int, s: bool = False, e: "Endianness | None" = None) -> bytes:
  function p16 (line 292) | def p16(x: int, s: bool = False, e: "Endianness | None" = None) -> bytes:
  function p32 (line 298) | def p32(x: int, s: bool = False, e: "Endianness | None" = None) -> bytes:
  function p64 (line 304) | def p64(x: int, s: bool = False, e: "Endianness | None" = None) -> bytes:
  function u8 (line 310) | def u8(x: bytes, s: bool = False, e: "Endianness | None" = None) -> int:
  function u16 (line 316) | def u16(x: bytes, s: bool = False, e: "Endianness | None" = None) -> int:
  function u32 (line 322) | def u32(x: bytes, s: bool = False, e: "Endianness | None" = None) -> int:
  function u64 (line 328) | def u64(x: bytes, s: bool = False, e: "Endianness | None" = None) -> int:
  function is_ascii_string (line 334) | def is_ascii_string(address: int) -> bool:
  function is_alive (line 342) | def is_alive() -> bool:
  function calling_function (line 350) | def calling_function() -> str | None:
  function only_if_gdb_running (line 363) | def only_if_gdb_running(f: Callable) -> Callable:
  function only_if_gdb_target_local (line 375) | def only_if_gdb_target_local(f: Callable) -> Callable:
  function deprecated (line 388) | def deprecated(solution: str = "") -> Callable:
  function experimental_feature (line 412) | def experimental_feature(f: Callable) -> Callable:
  function only_if_events_supported (line 423) | def only_if_events_supported(event_type: str) -> Callable:
  class classproperty (line 434) | class classproperty(property):
    method __get__ (line 436) | def __get__(self, cls, owner):
  function FakeExit (line 441) | def FakeExit(*args: Any, **kwargs: Any) -> NoReturn:
  function parse_arguments (line 448) | def parse_arguments(required_arguments: dict[str | tuple[str, str], Any],
  class Color (line 506) | class Color:
    method redify (line 535) | def redify(msg: str) -> str:        return Color.colorify(msg, "red")
    method greenify (line 537) | def greenify(msg: str) -> str:      return Color.colorify(msg, "green")
    method blueify (line 539) | def blueify(msg: str) -> str:       return Color.colorify(msg, "blue")
    method yellowify (line 541) | def yellowify(msg: str) -> str:     return Color.colorify(msg, "yellow")
    method grayify (line 543) | def grayify(msg: str) -> str:       return Color.colorify(msg, "gray")
    method light_grayify (line 545) | def light_grayify(msg: str) -> str: return Color.colorify(msg, "light_...
    method pinkify (line 547) | def pinkify(msg: str) -> str:       return Color.colorify(msg, "pink")
    method cyanify (line 549) | def cyanify(msg: str) -> str:       return Color.colorify(msg, "cyan")
    method boldify (line 551) | def boldify(msg: str) -> str:       return Color.colorify(msg, "bold")
    method underlinify (line 553) | def underlinify(msg: str) -> str:   return Color.colorify(msg, "underl...
    method highlightify (line 555) | def highlightify(msg: str) -> str:  return Color.colorify(msg, "highli...
    method blinkify (line 557) | def blinkify(msg: str) -> str:      return Color.colorify(msg, "blink")
    method colorify (line 560) | def colorify(text: str, attrs: str) -> str:
  class Address (line 574) | class Address:
    method __init__ (line 576) | def __init__(self, **kwargs: Any) -> None:
    method __str__ (line 582) | def __str__(self) -> str:
    method __int__ (line 595) | def __int__(self) -> int:
    method is_in_text_segment (line 598) | def is_in_text_segment(self) -> bool:
    method is_in_stack_segment (line 602) | def is_in_stack_segment(self) -> bool:
    method is_in_heap_segment (line 605) | def is_in_heap_segment(self) -> bool:
    method dereference (line 608) | def dereference(self) -> int | None:
    method valid (line 614) | def valid(self) -> bool:
  class Permission (line 618) | class Permission(enum.Flag):
    method __str__ (line 626) | def __str__(self) -> str:
    method from_info_sections (line 634) | def from_info_sections(cls, *args: str) -> "Permission":
    method from_process_maps (line 643) | def from_process_maps(cls, perm_str: str) -> "Permission":
    method from_monitor_info_mem (line 651) | def from_monitor_info_mem(cls, perm_str: str) -> "Permission":
    method from_info_mem (line 660) | def from_info_mem(cls, perm_str: str) -> "Permission":
  class Section (line 668) | class Section:
    method __init__ (line 671) | def __init__(self, **kwargs: Any) -> None:
    method is_readable (line 680) | def is_readable(self) -> bool:
    method is_writable (line 683) | def is_writable(self) -> bool:
    method is_executable (line 686) | def is_executable(self) -> bool:
    method size (line 690) | def size(self) -> int:
    method _search_for_realpath_without_versions (line 695) | def _search_for_realpath_without_versions(self, path: pathlib.Path) ->...
    method _search_for_realpath (line 710) | def _search_for_realpath(self) -> str | None:
    method realpath (line 743) | def realpath(self) -> str:
    method __str__ (line 752) | def __str__(self) -> str:
    method __repr__ (line 756) | def __repr__(self) -> str:
    method __eq__ (line 759) | def __eq__(self, other: "Section") -> bool:
    method overlaps (line 766) | def overlaps(self, other: "Section") -> bool:
    method contains (line 769) | def contains(self, addr: int) -> bool:
  class Endianness (line 776) | class Endianness(enum.Enum):
    method __str__ (line 780) | def __str__(self) -> str:
    method __repr__ (line 783) | def __repr__(self) -> str:
    method __int__ (line 786) | def __int__(self) -> int:
  class FileFormatSection (line 790) | class FileFormatSection:
  class FileFormat (line 794) | class FileFormat:
    method __init__ (line 801) | def __init__(self, path: str | pathlib.Path) -> None:
    method __init_subclass__ (line 804) | def __init_subclass__(cls: Type["FileFormat"], **kwargs):
    method is_valid (line 815) | def is_valid(cls, _: pathlib.Path) -> bool:
    method __str__ (line 818) | def __str__(self) -> str:
  class Elf (line 822) | class Elf(FileFormat):
    class Class (line 829) | class Class(enum.Enum):
    class Abi (line 835) | class Abi(enum.Enum):
    class Type (line 849) | class Type(enum.Enum):
    class OsAbi (line 855) | class OsAbi(enum.Enum):
    method __init__ (line 894) | def __init__(self, path: str | pathlib.Path) -> None:
    method read (line 952) | def read(self, size: int) -> bytes:
    method read_and_unpack (line 955) | def read_and_unpack(self, fmt: str) -> tuple[Any, ...]:
    method seek (line 960) | def seek(self, off: int) -> None:
    method __str__ (line 963) | def __str__(self) -> str:
    method __repr__ (line 966) | def __repr__(self) -> str:
    method entry_point (line 970) | def entry_point(self) -> int:
    method is_valid (line 974) | def is_valid(cls, path: pathlib.Path) -> bool:
    method checksec (line 978) | def checksec(self) -> dict[str, bool]:
    method X86_64 (line 1014) | def X86_64(cls) -> int: return Elf.Abi.X86_64.value # pylint: disable=...
    method X86_32 (line 1018) | def X86_32(cls) -> int : return Elf.Abi.X86_32.value # pylint: disable...
    method ARM (line 1022) | def ARM(cls) -> int : return Elf.Abi.ARM.value # pylint: disable=no-se...
    method MIPS (line 1026) | def MIPS(cls) -> int : return Elf.Abi.MIPS.value # pylint: disable=no-...
    method POWERPC (line 1030) | def POWERPC(cls) -> int : return Elf.Abi.POWERPC.value # pylint: disab...
    method POWERPC64 (line 1034) | def POWERPC64(cls) -> int : return Elf.Abi.POWERPC64.value # pylint: d...
    method SPARC (line 1038) | def SPARC(cls) -> int : return Elf.Abi.SPARC.value # pylint: disable=n...
    method SPARC64 (line 1042) | def SPARC64(cls) -> int : return Elf.Abi.SPARC64.value # pylint: disab...
    method AARCH64 (line 1046) | def AARCH64(cls) -> int : return Elf.Abi.AARCH64.value  # pylint: disa...
    method RISCV (line 1050) | def RISCV(cls) -> int : return Elf.Abi.RISCV.value # pylint: disable=n...
  class Phdr (line 1053) | class Phdr:
    class Type (line 1054) | class Type(enum.IntEnum):
      method _missing_ (line 1079) | def _missing_(cls, _:int) -> "Phdr.Type":
    class Flags (line 1082) | class Flags(enum.IntFlag):
    method __init__ (line 1096) | def __init__(self, elf: Elf, off: int) -> None:
    method __str__ (line 1114) | def __str__(self) -> str:
  class Shdr (line 1120) | class Shdr:
    class Type (line 1121) | class Type(enum.IntEnum):
      method _missing_ (line 1164) | def _missing_(cls, _:int) -> "Shdr.Type":
    class Flags (line 1167) | class Flags(enum.IntFlag):
      method _missing_ (line 1186) | def _missing_(cls, _:int):
    method __init__ (line 1201) | def __init__(self, elf: Elf | None, off: int) -> None:
    method __str__ (line 1236) | def __str__(self) -> str:
  class Instruction (line 1242) | class Instruction:
    method __init__ (line 1245) | def __init__(self, address: int, location: str, mnemo: str, operands: ...
    method __format__ (line 1252) | def __format__(self, format_spec: str) -> str:
    method __str__ (line 1267) | def __str__(self) -> str:
    method is_valid (line 1270) | def is_valid(self) -> bool:
    method size (line 1273) | def size(self) -> int:
    method next (line 1276) | def next(self) -> "Instruction":
  function search_for_main_arena (line 1282) | def search_for_main_arena() -> int:
  class GlibcHeapInfo (line 1285) | class GlibcHeapInfo:
    method heap_info_t (line 1289) | def heap_info_t() -> Type[ctypes.Structure]:
    method __init__ (line 1316) | def __init__(self, addr: str |  int) -> None:
    method reset (line 1321) | def reset(self):
    method __getattr__ (line 1327) | def __getattr__(self, item: Any) -> Any:
    method __abs__ (line 1332) | def __abs__(self) -> int:
    method __int__ (line 1335) | def __int__(self) -> int:
    method address (line 1339) | def address(self) -> int:
    method sizeof (line 1343) | def sizeof(self) -> int:
    method addr (line 1347) | def addr(self) -> int:
    method heap_start (line 1351) | def heap_start(self) -> int:
    method heap_end (line 1368) | def heap_end(self) -> int:
  class GlibcArena (line 1372) | class GlibcArena:
    method malloc_state_t (line 1383) | def malloc_state_t() -> Type[ctypes.Structure]:
    method __init__ (line 1417) | def __init__(self, addr: str) -> None:
    method reset (line 1427) | def reset(self):
    method __abs__ (line 1433) | def __abs__(self) -> int:
    method __int__ (line 1436) | def __int__(self) -> int:
    method __iter__ (line 1439) | def __iter__(self) -> Generator["GlibcArena", None, None]:
    method __eq__ (line 1454) | def __eq__(self, other: "GlibcArena") -> bool:
    method __str__ (line 1457) | def __str__(self) -> str:
    method __repr__ (line 1463) | def __repr__(self) -> str:
    method address (line 1467) | def address(self) -> int:
    method sizeof (line 1471) | def sizeof(self) -> int:
    method addr (line 1475) | def addr(self) -> int:
    method top (line 1479) | def top(self) -> int:
    method last_remainder (line 1483) | def last_remainder(self) -> int:
    method fastbinsY (line 1487) | def fastbinsY(self) -> ctypes.Array:
    method bins (line 1491) | def bins(self) -> ctypes.Array:
    method binmap (line 1495) | def binmap(self) -> ctypes.Array:
    method next (line 1499) | def next(self) -> int:
    method next_free (line 1503) | def next_free(self) -> int:
    method attached_threads (line 1507) | def attached_threads(self) -> int:
    method system_mem (line 1511) | def system_mem(self) -> int:
    method max_system_mem (line 1515) | def max_system_mem(self) -> int:
    method fastbin (line 1518) | def fastbin(self, i: int) -> "GlibcFastChunk | None":
    method bin (line 1525) | def bin(self, i: int) -> tuple[int, int]:
    method bin_at (line 1531) | def bin_at(self, i) -> int:
    method is_main_arena (line 1536) | def is_main_arena(self) -> bool:
    method heap_addr (line 1539) | def heap_addr(self, allow_unaligned: bool = False) -> int | None:
    method get_heap_info_list (line 1550) | def get_heap_info_list(self) -> list[GlibcHeapInfo] | None:
    method get_heap_for_ptr (line 1562) | def get_heap_for_ptr(ptr: int) -> int:
    method verify (line 1575) | def verify(addr: int) -> bool:
  class GlibcChunk (line 1590) | class GlibcChunk:
    class ChunkFlags (line 1595) | class ChunkFlags(enum.IntFlag):
      method __str__ (line 1600) | def __str__(self) -> str:
    method malloc_chunk_t (line 1608) | def malloc_chunk_t() -> Type[ctypes.Structure]:
    method __init__ (line 1623) | def __init__(self, addr: int, from_base: bool = False, allow_unaligned...
    method reset (line 1634) | def reset(self):
    method prev_size (line 1642) | def prev_size(self) -> int:
    method size (line 1646) | def size(self) -> int:
    method flags (line 1650) | def flags(self) -> ChunkFlags:
    method fd (line 1654) | def fd(self) -> int:
    method bk (line 1658) | def bk(self) -> int:
    method fd_nextsize (line 1662) | def fd_nextsize(self) -> int:
    method bk_nextsize (line 1666) | def bk_nextsize(self) -> int:
    method get_usable_size (line 1669) | def get_usable_size(self) -> int:
    method usable_size (line 1678) | def usable_size(self) -> int:
    method get_prev_chunk_size (line 1681) | def get_prev_chunk_size(self) -> int:
    method __iter__ (line 1684) | def __iter__(self) -> Generator["GlibcChunk", None, None]:
    method get_next_chunk (line 1710) | def get_next_chunk(self, allow_unaligned: bool = False) -> "GlibcChunk":
    method get_next_chunk_addr (line 1714) | def get_next_chunk_addr(self) -> int:
    method has_p_bit (line 1717) | def has_p_bit(self) -> bool:
    method has_m_bit (line 1720) | def has_m_bit(self) -> bool:
    method has_n_bit (line 1723) | def has_n_bit(self) -> bool:
    method is_used (line 1726) | def is_used(self) -> bool:
    method __str_sizes (line 1736) | def __str_sizes(self) -> str:
    method _str_pointers (line 1759) | def _str_pointers(self) -> str:
    method __str__ (line 1776) | def __str__(self) -> str:
    method psprint (line 1780) | def psprint(self) -> str:
    method resolve_type (line 1789) | def resolve_type(self) -> str:
  class GlibcFastChunk (line 1799) | class GlibcFastChunk(GlibcChunk):
    method fd (line 1802) | def fd(self) -> int:
    method protect_ptr (line 1808) | def protect_ptr(self, pos: int, pointer: int) -> int:
    method reveal_ptr (line 1815) | def reveal_ptr(self, pointer: int) -> int:
  class GlibcTcacheChunk (line 1822) | class GlibcTcacheChunk(GlibcFastChunk):
  function get_libc_version (line 1826) | def get_libc_version() -> tuple[int, ...]:
  function titlify (line 1829) | def titlify(text: str, color: str | None = None, msg_color: str | None =...
  function dbg (line 1842) | def dbg(msg: str) -> None:
  function err (line 1848) | def err(msg: str) -> None:
  function warn (line 1853) | def warn(msg: str) -> None:
  function ok (line 1858) | def ok(msg: str) -> None:
  function info (line 1863) | def info(msg: str) -> None:
  function push_context_message (line 1868) | def push_context_message(level: str, message: str) -> None:
  function show_last_exception (line 1877) | def show_last_exception() -> None:
  function gef_pystring (line 1921) | def gef_pystring(x: bytes) -> str:
  function gef_pybytes (line 1929) | def gef_pybytes(x: str) -> bytes:
  function which (line 1935) | def which(program: str) -> pathlib.Path:
  function style_byte (line 1943) | def style_byte(b: int, color: bool = True) -> str:
  function hexdump (line 1966) | def hexdump(source: ByteString, length: int = 0x10, separator: str = "."...
  function is_debug (line 1996) | def is_debug() -> bool:
  function buffer_output (line 2001) | def buffer_output() -> bool:
  function hide_context (line 2006) | def hide_context() -> bool:
  function unhide_context (line 2012) | def unhide_context() -> bool:
  class DisableContextOutputContext (line 2018) | class DisableContextOutputContext:
    method __enter__ (line 2019) | def __enter__(self) -> None:
    method __exit__ (line 2023) | def __exit__(self, *exc: Any) -> None:
  class RedirectOutputContext (line 2028) | class RedirectOutputContext:
    method __init__ (line 2029) | def __init__(self, to_file: str = "/dev/null") -> None:
    method __enter__ (line 2034) | def __enter__(self) -> None:
    method __exit__ (line 2046) | def __exit__(self, *exc: Any) -> None:
  function enable_redirect_output (line 2056) | def enable_redirect_output(to_file: str = "/dev/null") -> None:
  function disable_redirect_output (line 2070) | def disable_redirect_output() -> None:
  function gef_makedirs (line 2080) | def gef_makedirs(path: str, mode: int = 0o755) -> pathlib.Path:
  function gdb_lookup_symbol (line 2089) | def gdb_lookup_symbol(sym: str) -> tuple[gdb.Symtab_and_line, ...] | None:
  function gdb_get_location_from_symbol (line 2098) | def gdb_get_location_from_symbol(address: int) -> tuple[str, int] | None:
  function gdb_disassemble (line 2117) | def gdb_disassemble(start_pc: int, **kwargs: int) -> Generator[Instructi...
  function gdb_get_nth_previous_instruction_address (line 2149) | def gdb_get_nth_previous_instruction_address(addr: int, n: int) -> int |...
  function gdb_get_nth_next_instruction_address (line 2187) | def gdb_get_nth_next_instruction_address(addr: int, n: int) -> int:
  function gef_instruction_n (line 2192) | def gef_instruction_n(addr: int, n: int) -> Instruction:
  function gef_get_instruction_at (line 2198) | def gef_get_instruction_at(addr: int) -> Instruction:
  function gef_current_instruction (line 2204) | def gef_current_instruction(addr: int) -> Instruction:
  function gef_next_instruction (line 2209) | def gef_next_instruction(addr: int) -> Instruction:
  function gef_disassemble (line 2214) | def gef_disassemble(addr: int, nb_insn: int, nb_prev: int = 0) -> Genera...
  function gef_execute_external (line 2234) | def gef_execute_external(command: Sequence[str], as_list: bool = False, ...
  function gef_execute_gdb_script (line 2240) | def gef_execute_gdb_script(commands: str) -> None:
  function checksec (line 2256) | def checksec(filename: str) -> dict[str, bool]:
  function get_arch (line 2261) | def get_arch() -> str:
  function get_entry_point (line 2289) | def get_entry_point() -> int | None:
  function is_pie (line 2294) | def is_pie(fpath: str) -> bool:
  function is_big_endian (line 2299) | def is_big_endian() -> bool:
  function is_little_endian (line 2304) | def is_little_endian() -> bool:
  function flags_to_human (line 2308) | def flags_to_human(reg_value: int, value_table: dict[int, str]) -> str:
  function get_section_base_address (line 2317) | def get_section_base_address(name: str) -> int | None:
  function get_zone_base_address (line 2323) | def get_zone_base_address(name: str) -> int | None:
  function register_architecture (line 2333) | def register_architecture(cls: Type["Architecture"]) -> Type["Architectu...
  class ArchitectureBase (line 2336) | class ArchitectureBase:
    method __init_subclass__ (line 2340) | def __init_subclass__(cls: Type["ArchitectureBase"], **kwargs):
  class Architecture (line 2352) | class Architecture(ArchitectureBase):
    method __init_subclass__ (line 2374) | def __init_subclass__(cls, **kwargs):
    method __str__ (line 2382) | def __str__(self) -> str:
    method __repr__ (line 2385) | def __repr__(self) -> str:
    method supports_gdb_arch (line 2389) | def supports_gdb_arch(gdb_arch: str) -> bool | None:
    method flag_register_to_human (line 2395) | def flag_register_to_human(self, val: int | None = None) -> str:
    method is_call (line 2398) | def is_call(self, insn: Instruction) -> bool:
    method is_ret (line 2401) | def is_ret(self, insn: Instruction) -> bool:
    method is_conditional_branch (line 2404) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 2407) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
    method get_ra (line 2410) | def get_ra(self, insn: Instruction, frame: "gdb.Frame") -> int | None:
    method canary_address (line 2413) | def canary_address(self) -> int:
    method mprotect_asm (line 2417) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
    method reset_caches (line 2420) | def reset_caches(self) -> None:
    method __get_register (line 2424) | def __get_register(self, regname: str) -> int:
    method __get_register_for_selected_frame (line 2431) | def __get_register_for_selected_frame(self, regname: str, hash_key: in...
    method register (line 2443) | def register(self, name: str) -> int:
    method registers (line 2449) | def registers(self) -> Generator[str, None, None]:
    method pc (line 2453) | def pc(self) -> int:
    method sp (line 2457) | def sp(self) -> int:
    method fp (line 2461) | def fp(self) -> int:
    method ptrsize (line 2465) | def ptrsize(self) -> int:
    method endianness (line 2475) | def endianness(self) -> Endianness:
    method get_ith_parameter (line 2486) | def get_ith_parameter(self, i: int, in_func: bool = True) -> tuple[str...
  class GenericArchitecture (line 2494) | class GenericArchitecture(Architecture):
  class RISCV (line 2509) | class RISCV(Architecture):
    method instruction_length (line 2528) | def instruction_length(self) -> int:
    method is_call (line 2531) | def is_call(self, insn: Instruction) -> bool:
    method is_ret (line 2534) | def is_ret(self, insn: Instruction) -> bool:
    method mprotect_asm (line 2546) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
    method ptrsize (line 2550) | def ptrsize(self) -> int:
    method is_conditional_branch (line 2558) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 2561) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
    method get_ra (line 2617) | def get_ra(self, insn: Instruction, frame: "gdb.Frame") -> int | None:
    method flag_register_to_human (line 2627) | def flag_register_to_human(self, val: int | None = None) -> str:
  class ARM (line 2632) | class ARM(Architecture):
    method is_thumb (line 2656) | def is_thumb(self) -> bool:
    method pc (line 2661) | def pc(self) -> int | None:
    method cpsr (line 2668) | def cpsr(self) -> int:
    method mode (line 2674) | def mode(self) -> str:
    method instruction_length (line 2678) | def instruction_length(self) -> int | None:
    method ptrsize (line 2683) | def ptrsize(self) -> int:
    method is_call (line 2686) | def is_call(self, insn: Instruction) -> bool:
    method is_ret (line 2691) | def is_ret(self, insn: Instruction) -> bool:
    method flag_register_to_human (line 2703) | def flag_register_to_human(self, val: int | None = None) -> str:
    method is_conditional_branch (line 2710) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 2714) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
    method get_ra (line 2747) | def get_ra(self, insn: Instruction, frame: "gdb.Frame") -> int | None:
    method mprotect_asm (line 2772) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
  class AARCH64 (line 2789) | class AARCH64(ARM):
    method is_call (line 2818) | def is_call(self, insn: Instruction) -> bool:
    method flag_register_to_human (line 2823) | def flag_register_to_human(self, val: int | None = None) -> str:
    method is_aarch32 (line 2830) | def is_aarch32(self) -> bool:
    method is_thumb32 (line 2834) | def is_thumb32(self) -> bool:
    method ptrsize (line 2839) | def ptrsize(self) -> int:
    method mprotect_asm (line 2850) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
    method is_conditional_branch (line 2873) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 2880) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
  class X86 (line 2911) | class X86(Architecture):
    method flag_register_to_human (line 2943) | def flag_register_to_human(self, val: int | None = None) -> str:
    method is_call (line 2949) | def is_call(self, insn: Instruction) -> bool:
    method is_ret (line 2954) | def is_ret(self, insn: Instruction) -> bool:
    method is_conditional_branch (line 2957) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 2967) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
    method get_ra (line 3012) | def get_ra(self, insn: Instruction, frame: "gdb.Frame") -> int | None:
    method mprotect_asm (line 3025) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
    method get_ith_parameter (line 3040) | def get_ith_parameter(self, i: int, in_func: bool = True) -> tuple[str...
  class X86_64 (line 3051) | class X86_64(X86):
    method mprotect_asm (line 3069) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
    method canary_address (line 3094) | def canary_address(self) -> int:
  class PowerPC (line 3097) | class PowerPC(Architecture):
    method flag_register_to_human (line 3129) | def flag_register_to_human(self, val: int | None = None) -> str:
    method is_call (line 3136) | def is_call(self, insn: Instruction) -> bool:
    method is_ret (line 3139) | def is_ret(self, insn: Instruction) -> bool:
    method is_conditional_branch (line 3142) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 3147) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
    method get_ra (line 3160) | def get_ra(self, insn: Instruction, frame: "gdb.Frame") -> int | None:
    method mprotect_asm (line 3171) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
  class PowerPC64 (line 3196) | class PowerPC64(PowerPC):
  class SPARC (line 3203) | class SPARC(Architecture):
    method flag_register_to_human (line 3233) | def flag_register_to_human(self, val: int | None = None) -> str:
    method is_call (line 3240) | def is_call(self, insn: Instruction) -> bool:
    method is_ret (line 3243) | def is_ret(self, insn: Instruction) -> bool:
    method is_conditional_branch (line 3246) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 3255) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
    method get_ra (line 3279) | def get_ra(self, insn: Instruction, frame: "gdb.Frame") -> int | None:
    method mprotect_asm (line 3290) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
  class SPARC64 (line 3309) | class SPARC64(SPARC):
    method mprotect_asm (line 3336) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
  class MIPS (line 3355) | class MIPS(Architecture):
    method flag_register_to_human (line 3377) | def flag_register_to_human(self, val: int | None = None) -> str:
    method is_call (line 3380) | def is_call(self, insn: Instruction) -> bool:
    method is_ret (line 3383) | def is_ret(self, insn: Instruction) -> bool:
    method is_conditional_branch (line 3386) | def is_conditional_branch(self, insn: Instruction) -> bool:
    method is_branch_taken (line 3391) | def is_branch_taken(self, insn: Instruction) -> tuple[bool, str]:
    method get_ra (line 3413) | def get_ra(self, insn: Instruction, frame: "gdb.Frame") -> int | None:
    method mprotect_asm (line 3424) | def mprotect_asm(cls, addr: int, size: int, perm: Permission) -> str:
  class MIPS64 (line 3440) | class MIPS64(MIPS):
    method supports_gdb_arch (line 3447) | def supports_gdb_arch(gdb_arch: str) -> bool | None:
  function copy_to_clipboard (line 3453) | def copy_to_clipboard(data: bytes) -> None:
  function use_stdtype (line 3472) | def use_stdtype() -> str:
  function use_default_type (line 3478) | def use_default_type() -> str:
  function use_golang_type (line 3484) | def use_golang_type() -> str:
  function use_rust_type (line 3490) | def use_rust_type() -> str:
  function to_unsigned_long (line 3496) | def to_unsigned_long(v: gdb.Value) -> int:
  function get_path_from_info_proc (line 3502) | def get_path_from_info_proc() -> str | None:
  function get_os (line 3510) | def get_os() -> str:
  function is_qemu (line 3515) | def is_qemu() -> bool:
  function is_qemu_usermode (line 3523) | def is_qemu_usermode() -> bool:
  function is_qemu_system (line 3531) | def is_qemu_system() -> bool:
  function is_target_coredump (line 3538) | def is_target_coredump() -> bool:
  function get_filepath (line 3548) | def get_filepath() -> str | None:
  function get_function_length (line 3557) | def get_function_length(sym: str) -> int:
  function get_info_files (line 3566) | def get_info_files() -> list[Zone]:
  function process_lookup_address (line 3592) | def process_lookup_address(address: int) -> Section | None:
  function process_lookup_path (line 3611) | def process_lookup_path(name: str, perm: Permission = Permission.ALL) ->...
  function file_lookup_name_path (line 3643) | def file_lookup_name_path(name: str, path: str) -> Zone | None:
  function file_lookup_address (line 3653) | def file_lookup_address(address: int) -> Zone | None:
  function lookup_address (line 3663) | def lookup_address(address: int) -> Address:
  function xor (line 3674) | def xor(data: ByteString, key: str) -> bytearray:
  function is_hex (line 3680) | def is_hex(pattern: str) -> bool:
  function continue_handler (line 3687) | def continue_handler(_: "gdb.ContinueEvent") -> None:
  function hook_stop_handler (line 3692) | def hook_stop_handler(_: "gdb.StopEvent") -> None:
  function new_objfile_handler (line 3699) | def new_objfile_handler(evt: "gdb.NewObjFileEvent | None") -> None:
  function exit_handler (line 3734) | def exit_handler(_: "gdb.ExitedEvent") -> None:
  function memchanged_handler (line 3765) | def memchanged_handler(_: "gdb.MemoryChangedEvent") -> None:
  function regchanged_handler (line 3771) | def regchanged_handler(_: "gdb.RegisterChangedEvent") -> None:
  function get_terminal_size (line 3777) | def get_terminal_size() -> tuple[int, int]:
  function is_64bit (line 3806) | def is_64bit() -> bool:
  function is_32bit (line 3812) | def is_32bit() -> bool:
  function is_x86_64 (line 3818) | def is_x86_64() -> bool:
  function is_x86_32 (line 3824) | def is_x86_32():
  function is_x86 (line 3830) | def is_x86() -> bool:
  function is_arch (line 3835) | def is_arch(arch: Elf.Abi) -> bool:
  function reset_architecture (line 3839) | def reset_architecture(arch: str | None = None) -> None:
  function cached_lookup_type (line 3880) | def cached_lookup_type(_type: str) -> gdb.Type | None:
  function get_memory_alignment (line 3888) | def get_memory_alignment(in_bits: bool = False) -> int:
  function clear_screen (line 3907) | def clear_screen(tty: str = "") -> None:
  function format_address (line 3918) | def format_address(addr: int) -> str:
  function format_address_spaces (line 3925) | def format_address_spaces(addr: int, left: bool = True) -> str:
  function align_address (line 3936) | def align_address(address: int) -> int:
  function align_address_to_size (line 3941) | def align_address_to_size(address: int, align: int) -> int:
  function align_address_to_page (line 3946) | def align_address_to_page(address: int) -> int:
  function parse_address (line 3952) | def parse_address(address: str) -> int:
  function is_in_x86_kernel (line 3959) | def is_in_x86_kernel(address: int) -> bool:
  function is_remote_debug (line 3965) | def is_remote_debug() -> bool:
  function de_bruijn (line 3970) | def de_bruijn(alphabet: bytes, n: int) -> Generator[int, None, None]:
  function generate_cyclic_pattern (line 3991) | def generate_cyclic_pattern(length: int, cycle: int = 4) -> bytearray:
  function safe_parse_and_eval (line 3997) | def safe_parse_and_eval(value: str) -> "gdb.Value | None":
  function dereference (line 4008) | def dereference(addr: int) -> "gdb.Value | None":
  function gef_convenience (line 4027) | def gef_convenience(value: str |  bytes) -> str:
  function parse_string_range (line 4042) | def parse_string_range(s: str) -> Iterator[int]:
  function is_syscall (line 4049) | def is_syscall(instruction: Instruction | int) -> bool:
  function gef_get_pie_breakpoint (line 4064) | def gef_get_pie_breakpoint(num: int) -> "PieVirtualBreakpoint":
  function endian_str (line 4069) | def endian_str() -> str:
  function get_gef_setting (line 4074) | def get_gef_setting(name: str) -> Any:
  function set_gef_setting (line 4079) | def set_gef_setting(name: str, value: Any) -> None:
  function gef_getpagesize (line 4085) | def gef_getpagesize() -> int:
  function gef_read_canary (line 4090) | def gef_read_canary() -> tuple[int, int] | None:
  function get_pid (line 4095) | def get_pid() -> int:
  function get_filename (line 4100) | def get_filename() -> str:
  function get_glibc_arena (line 4106) | def get_glibc_arena() -> GlibcArena | None:
  function get_register (line 4111) | def get_register(regname) -> int | None:
  function get_process_maps (line 4116) | def get_process_maps() -> list[Section]:
  function set_arch (line 4121) | def set_arch(arch: str | None = None, _: str | None = None) -> None:
  function gef_on_continue_hook (line 4129) | def gef_on_continue_hook(func: Callable[["gdb.ContinueEvent"], None]) ->...
  function gef_on_continue_unhook (line 4134) | def gef_on_continue_unhook(func: Callable[["gdb.ThreadEvent"], None]) ->...
  function gef_on_stop_hook (line 4139) | def gef_on_stop_hook(func: Callable[["gdb.StopEvent"], None]) -> None:
  function gef_on_stop_unhook (line 4144) | def gef_on_stop_unhook(func: Callable[["gdb.StopEvent"], None]) -> None:
  function gef_on_exit_hook (line 4149) | def gef_on_exit_hook(func: Callable[["gdb.ExitedEvent"], None]) -> None:
  function gef_on_exit_unhook (line 4154) | def gef_on_exit_unhook(func: Callable[["gdb.ExitedEvent"], None]) -> None:
  function gef_on_new_hook (line 4159) | def gef_on_new_hook(func: Callable[["gdb.NewObjFileEvent"], None]) -> None:
  function gef_on_new_unhook (line 4164) | def gef_on_new_unhook(func: Callable[["gdb.NewObjFileEvent"], None]) -> ...
  function gef_on_unload_objfile_hook (line 4169) | def gef_on_unload_objfile_hook(func: Callable[["gdb.ClearObjFilesEvent"]...
  function gef_on_unload_objfile_unhook (line 4174) | def gef_on_unload_objfile_unhook(func: Callable[["gdb.ClearObjFilesEvent...
  function gef_on_memchanged_hook (line 4179) | def gef_on_memchanged_hook(func: Callable[["gdb.MemoryChangedEvent"], No...
  function gef_on_memchanged_unhook (line 4184) | def gef_on_memchanged_unhook(func: Callable[["gdb.MemoryChangedEvent"], ...
  function gef_on_regchanged_hook (line 4189) | def gef_on_regchanged_hook(func: Callable[["gdb.RegisterChangedEvent"], ...
  function gef_on_regchanged_unhook (line 4194) | def gef_on_regchanged_unhook(func: Callable[["gdb.RegisterChangedEvent"]...
  class PieVirtualBreakpoint (line 4202) | class PieVirtualBreakpoint:
    method __init__ (line 4205) | def __init__(self, set_func: Callable[[int], str], vbp_num: int, addr:...
    method instantiate (line 4220) | def instantiate(self, base: int) -> None:
    method destroy (line 4240) | def destroy(self) -> None:
  class FormatStringBreakpoint (line 4253) | class FormatStringBreakpoint(gdb.Breakpoint):
    method __init__ (line 4255) | def __init__(self, spec: str, num_args: int) -> None:
    method stop (line 4261) | def stop(self) -> bool:
  class StubBreakpoint (line 4283) | class StubBreakpoint(gdb.Breakpoint):
    method __init__ (line 4286) | def __init__(self, func: str, retval: int | None) -> None:
    method stop (line 4297) | def stop(self) -> bool:
  class ChangePermissionBreakpoint (line 4305) | class ChangePermissionBreakpoint(gdb.Breakpoint):
    method __init__ (line 4309) | def __init__(self, loc: str, code: ByteString, pc: int) -> None:
    method stop (line 4315) | def stop(self) -> bool:
  class TraceMallocBreakpoint (line 4323) | class TraceMallocBreakpoint(gdb.Breakpoint):
    method __init__ (line 4326) | def __init__(self, name: str) -> None:
    method stop (line 4332) | def stop(self) -> bool:
  class TraceMallocRetBreakpoint (line 4340) | class TraceMallocRetBreakpoint(gdb.FinishBreakpoint):
    method __init__ (line 4343) | def __init__(self, size: int, name: str) -> None:
    method stop (line 4350) | def stop(self) -> bool:
  class TraceReallocBreakpoint (line 4409) | class TraceReallocBreakpoint(gdb.Breakpoint):
    method __init__ (line 4412) | def __init__(self) -> None:
    method stop (line 4417) | def stop(self) -> bool:
  class TraceReallocRetBreakpoint (line 4425) | class TraceReallocRetBreakpoint(gdb.FinishBreakpoint):
    method __init__ (line 4428) | def __init__(self, ptr: int, size: int) -> None:
    method stop (line 4435) | def stop(self) -> bool:
  class TraceFreeBreakpoint (line 4466) | class TraceFreeBreakpoint(gdb.Breakpoint):
    method __init__ (line 4469) | def __init__(self) -> None:
    method stop (line 4474) | def stop(self) -> bool:
  class TraceFreeRetBreakpoint (line 4528) | class TraceFreeRetBreakpoint(gdb.FinishBreakpoint):
    method __init__ (line 4531) | def __init__(self, addr: int) -> None:
    method stop (line 4537) | def stop(self) -> bool:
  class UafWatchpoint (line 4544) | class UafWatchpoint(gdb.Breakpoint):
    method __init__ (line 4547) | def __init__(self, addr: int) -> None:
    method stop (line 4554) | def stop(self) -> bool:
  class EntryBreakBreakpoint (line 4575) | class EntryBreakBreakpoint(gdb.Breakpoint):
    method __init__ (line 4578) | def __init__(self, location: str) -> None:
    method stop (line 4583) | def stop(self) -> bool:
  class NamedBreakpoint (line 4588) | class NamedBreakpoint(gdb.Breakpoint):
    method __init__ (line 4591) | def __init__(self, location: str, name: str) -> None:
    method stop (line 4597) | def stop(self) -> bool:
  class JustSilentStopBreakpoint (line 4603) | class JustSilentStopBreakpoint(gdb.Breakpoint):
    method __init__ (line 4606) | def __init__(self, loc: str) -> None:
  function register_external_context_pane (line 4616) | def register_external_context_pane(pane_name: str, display_pane_function...
  function register_external_context_layout_mapping (line 4637) | def register_external_context_layout_mapping(current_pane_name: str, dis...
  function register_external_command (line 4646) | def register_external_command(cls: Type["GenericCommand"]) -> Type["Gene...
  function register_command (line 4651) | def register_command(cls: Type["GenericCommand"]) -> Type["GenericComman...
  function register_priority_command (line 4656) | def register_priority_command(cls: Type["GenericCommand"]) -> Type["Gene...
  function register (line 4665) | def register(cls: Type["ValidCommandType"] |  Type["ValidFunctionType"])...
  class GenericCommand (line 4686) | class GenericCommand(gdb.Command):
    method __init_subclass__ (line 4694) | def __init_subclass__(cls, **kwargs):
    method __init__ (line 4700) | def __init__(self, *args: Any, **kwargs: Any) -> None:
    method invoke (line 4720) | def invoke(self, args: str, from_tty: bool) -> None:
    method usage (line 4736) | def usage(self) -> None:
    method do_invoke (line 4740) | def do_invoke(self, argv: list[str]) -> None:
    method pre_load (line 4743) | def pre_load(self) -> None:
    method post_load (line 4746) | def post_load(self) -> None:
    method __get_setting_name (line 4749) | def __get_setting_name(self, name: str) -> str:
    method __iter__ (line 4753) | def __iter__(self) -> Generator[str, None, None]:
    method settings (line 4759) | def settings(self) -> list[str]:
    method get_setting (line 4764) | def get_setting(self, name: str) -> Any:
    method __getitem__ (line 4767) | def __getitem__(self, name: str) -> Any:
    method has_setting (line 4772) | def has_setting(self, name: str) -> bool:
    method __contains__ (line 4775) | def __contains__(self, name: str) -> bool:
    method add_setting (line 4779) | def add_setting(self, name: str, value: tuple[Any, type, str], descrip...
    method __setitem__ (line 4782) | def __setitem__(self, name: str, value: "GefSetting | tuple[Any, str]"...
    method del_setting (line 4804) | def del_setting(self, name: str) -> None:
    method __delitem__ (line 4807) | def __delitem__(self, name: str) -> None:
    method __set_repeat_count (line 4811) | def __set_repeat_count(self, argv: list[str], from_tty: bool) -> None:
  class ArchCommand (line 4825) | class ArchCommand(GenericCommand):
    method __init__ (line 4832) | def __init__(self) -> None:
    method do_invoke (line 4836) | def do_invoke(self, argv: list[str]) -> None:
  class ArchGetCommand (line 4842) | class ArchGetCommand(GenericCommand):
    method do_invoke (line 4849) | def do_invoke(self, args: list[str]) -> None:
  class ArchSetCommand (line 4855) | class ArchSetCommand(GenericCommand):
    method do_invoke (line 4862) | def do_invoke(self, args: list[str]) -> None:
    method complete (line 4865) | def complete(self, text: str, word: str) -> list[str]:
  class ArchListCommand (line 4870) | class ArchListCommand(GenericCommand):
    method do_invoke (line 4877) | def do_invoke(self, args: list[str]) -> None:
  class VersionCommand (line 4890) | class VersionCommand(GenericCommand):
    method do_invoke (line 4897) | def do_invoke(self, argv: list[str]) -> None:
  class PrintFormatCommand (line 4927) | class PrintFormatCommand(GenericCommand):
    method __init__ (line 4943) | def __init__(self) -> None:
    method format_matrix (line 4949) | def format_matrix(self) -> dict[int, tuple[str, str, str]]:
    method do_invoke (line 4960) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class PieCommand (line 5018) | class PieCommand(GenericCommand):
    method __init__ (line 5024) | def __init__(self) -> None:
    method do_invoke (line 5028) | def do_invoke(self, argv: list[str]) -> None:
  class PieBreakpointCommand (line 5035) | class PieBreakpointCommand(GenericCommand):
    method do_invoke (line 5042) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
    method set_pie_breakpoint (line 5060) | def set_pie_breakpoint(set_func: Callable[[int], str], addr: int) -> N...
  class PieInfoCommand (line 5067) | class PieInfoCommand(GenericCommand):
    method do_invoke (line 5074) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class PieDeleteCommand (line 5093) | class PieDeleteCommand(GenericCommand):
    method do_invoke (line 5100) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
    method delete_bp (line 5115) | def delete_bp(breakpoints: list[PieVirtualBreakpoint]) -> None:
  class PieRunCommand (line 5127) | class PieRunCommand(GenericCommand):
    method do_invoke (line 5133) | def do_invoke(self, argv: list[str]) -> None:
  class PieAttachCommand (line 5170) | class PieAttachCommand(GenericCommand):
    method do_invoke (line 5176) | def do_invoke(self, argv: list[str]) -> None:
  class PieRemoteCommand (line 5194) | class PieRemoteCommand(GenericCommand):
    method do_invoke (line 5200) | def do_invoke(self, argv: list[str]) -> None:
  class SmartEvalCommand (line 5218) | class SmartEvalCommand(GenericCommand):
    method do_invoke (line 5226) | def do_invoke(self, argv: list[str]) -> None:
    method evaluate (line 5236) | def evaluate(self, expr: list[str]) -> None:
    method distance (line 5273) | def distance(self, args: list[str]) -> None:
  class CanaryCommand (line 5284) | class CanaryCommand(GenericCommand):
    method do_invoke (line 5291) | def do_invoke(self, argv: list[str]) -> None:
  class ProcessStatusCommand (line 5312) | class ProcessStatusCommand(GenericCommand):
    method __init__ (line 5320) | def __init__(self) -> None:
    method do_invoke (line 5326) | def do_invoke(self, argv: list[str]) -> None:
    method get_state_of (line 5334) | def get_state_of(self, pid: int) -> dict[str, str]:
    method get_cmdline_of (line 5343) | def get_cmdline_of(self, pid: int) -> str:
    method get_process_path_of (line 5347) | def get_process_path_of(self, pid: int) -> str:
    method get_children_pids (line 5350) | def get_children_pids(self, pid: int) -> list[int]:
    method show_info_proc (line 5357) | def show_info_proc(self) -> None:
    method show_ancestor (line 5366) | def show_ancestor(self) -> None:
    method show_descendants (line 5375) | def show_descendants(self) -> None:
    method show_fds (line 5389) | def show_fds(self) -> None:
    method list_sockets (line 5405) | def list_sockets(self, pid: int) -> list[int]:
    method parse_ip_port (line 5416) | def parse_ip_port(self, addr: str) -> tuple[str, int]:
    method show_connections (line 5420) | def show_connections(self) -> None:
  class GefThemeCommand (line 5469) | class GefThemeCommand(GenericCommand):
    method __init__ (line 5476) | def __init__(self) -> None:
    method do_invoke (line 5497) | def do_invoke(self, args: list[str]) -> None:
  class ExternalStructureManager (line 5522) | class ExternalStructureManager:
    class Structure (line 5523) | class Structure:
      method __init__ (line 5524) | def __init__(self, manager: "ExternalStructureManager", mod_path: pa...
      method __str__ (line 5534) | def __str__(self) -> str:
      method pprint (line 5537) | def pprint(self) -> None:
      method __get_structure_class (line 5549) | def __get_structure_class(self) -> Type[ctypes.Structure]:
      method apply_at (line 5560) | def apply_at(self, address: int, max_depth: int, depth: int = 0) -> ...
      method __get_ctypes_value (line 5616) | def __get_ctypes_value(self, struct, item, value) -> str:
    class Module (line 5631) | class Module(dict):
      method __init__ (line 5632) | def __init__(self, manager: "ExternalStructureManager", path: pathli...
      method __load (line 5643) | def __load(self) -> ModuleType:
      method __str__ (line 5653) | def __str__(self) -> str:
      method __iter__ (line 5656) | def __iter__(self) -> Generator[str, None, None]:
    class Modules (line 5673) | class Modules(dict):
      method __init__ (line 5674) | def __init__(self, manager: "ExternalStructureManager") -> None:
      method __contains__ (line 5686) | def __contains__(self, structure_name: str) -> bool:
    method __init__ (line 5693) | def __init__(self) -> None:
    method clear_caches (line 5697) | def clear_caches(self) -> None:
    method modules (line 5703) | def modules(self) -> "ExternalStructureManager.Modules":
    method path (line 5709) | def path(self) -> pathlib.Path:
    method structures (line 5715) | def structures(self) -> Generator[tuple["ExternalStructureManager.Modu...
    method find (line 5722) | def find(self, structure_name: str) -> tuple["ExternalStructureManager...
  class PCustomCommand (line 5731) | class PCustomCommand(GenericCommand):
    method __init__ (line 5742) | def __init__(self) -> None:
    method do_invoke (line 5755) | def do_invoke(self, *_: Any, **kwargs: dict[str, Any]) -> None:
    method explode_type (line 5782) | def explode_type(self, arg: str) -> tuple[str, str]:
  class PCustomListCommand (line 5789) | class PCustomListCommand(PCustomCommand):
    method __init__ (line 5795) | def __init__(self) -> None:
    method do_invoke (line 5799) | def do_invoke(self, _: list[str]) -> None:
  class PCustomShowCommand (line 5813) | class PCustomShowCommand(PCustomCommand):
    method __init__ (line 5820) | def __init__(self) -> None:
    method do_invoke (line 5824) | def do_invoke(self, argv: list[str]) -> None:
  class PCustomEditCommand (line 5841) | class PCustomEditCommand(PCustomCommand):
    method __init__ (line 5848) | def __init__(self) -> None:
    method do_invoke (line 5852) | def do_invoke(self, argv: list[str]) -> None:
    method __create_or_edit_structure (line 5861) | def __create_or_edit_structure(self, mod_name: str, struct_name: str) ...
    method __create_template (line 5873) | def __create_template(self, structname: str, fpath: pathlib.Path) -> N...
  class ChangeFdCommand (line 5887) | class ChangeFdCommand(GenericCommand):
    method do_invoke (line 5896) | def do_invoke(self, argv: list[str]) -> None:
    method get_fd_from_result (line 5957) | def get_fd_from_result(self, res: str) -> int:
  class ScanSectionCommand (line 5964) | class ScanSectionCommand(GenericCommand):
    method do_invoke (line 5974) | def do_invoke(self, argv: list[str]) -> None:
  class SearchPatternCommand (line 6039) | class SearchPatternCommand(GenericCommand):
    method __init__ (line 6051) | def __init__(self) -> None:
    method print_section (line 6057) | def print_section(self, section: Section) -> None:
    method print_loc (line 6067) | def print_loc(self, loc: tuple[int, int, str]) -> None:
    method search_pattern_by_address (line 6071) | def search_pattern_by_address(self, pattern: str, start_address: int, ...
    method search_binpattern_by_address (line 6103) | def search_binpattern_by_address(self, binpattern: bytes, start_addres...
    method search_pattern (line 6134) | def search_pattern(self, pattern: str, section_name: str) -> None:
    method do_invoke (line 6156) | def do_invoke(self, argv: list[str]) -> None:
  class FlagsCommand (line 6212) | class FlagsCommand(GenericCommand):
    method do_invoke (line 6221) | def do_invoke(self, argv: list[str]) -> None:
  class RemoteCommand (line 6259) | class RemoteCommand(GenericCommand):
    method __init__ (line 6272) | def __init__(self) -> None:
    method do_invoke (line 6277) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class SkipiCommand (line 6320) | class SkipiCommand(GenericCommand):
    method __init__ (line 6333) | def __init__(self) -> None:
    method do_invoke (line 6339) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class StepoverCommand (line 6354) | class StepoverCommand(GenericCommand):
    method __init__ (line 6363) | def __init__(self) -> None:
    method do_invoke (line 6368) | def do_invoke(self, _: list[str]) -> None:
  class NopCommand (line 6376) | class NopCommand(GenericCommand):
    method __init__ (line 6395) | def __init__(self) -> None:
    method do_invoke (line 6401) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class StubCommand (line 6468) | class StubCommand(GenericCommand):
    method __init__ (line 6478) | def __init__(self) -> None:
    method do_invoke (line 6484) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class GlibcHeapCommand (line 6492) | class GlibcHeapCommand(GenericCommand):
    method __init__ (line 6498) | def __init__(self) -> None:
    method do_invoke (line 6503) | def do_invoke(self, _: list[str]) -> None:
  class GlibcHeapSetArenaCommand (line 6509) | class GlibcHeapSetArenaCommand(GenericCommand):
    method __init__ (line 6516) | def __init__(self) -> None:
    method do_invoke (line 6522) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class GlibcHeapArenaCommand (line 6552) | class GlibcHeapArenaCommand(GenericCommand):
    method do_invoke (line 6559) | def do_invoke(self, _: list[str]) -> None:
  class GlibcHeapChunkCommand (line 6566) | class GlibcHeapChunkCommand(GenericCommand):
    method __init__ (line 6573) | def __init__(self) -> None:
    method do_invoke (line 6579) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class GlibcHeapChunkSummary (line 6609) | class GlibcHeapChunkSummary:
    method __init__ (line 6610) | def __init__(self, desc = ""):
    method process_chunk (line 6615) | def process_chunk(self, chunk: GlibcChunk) -> None:
  class GlibcHeapArenaSummary (line 6620) | class GlibcHeapArenaSummary:
    method __init__ (line 6621) | def __init__(self, resolve_type = False) -> None:
    method process_chunk (line 6630) | def process_chunk(self, chunk: GlibcChunk) -> None:
    method print (line 6646) | def print(self) -> None:
  class GlibcHeapWalkContext (line 6657) | class GlibcHeapWalkContext:
    method __init__ (line 6658) | def __init__(self, print_arena: bool = False, allow_unaligned: bool = ...
  class GlibcHeapChunksCommand (line 6668) | class GlibcHeapChunksCommand(GenericCommand):
    method __init__ (line 6677) | def __init__(self) -> None:
    method do_invoke (line 6684) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
    method dump_chunks_arena (line 6702) | def dump_chunks_arena(self, arena: GlibcArena, ctx: GlibcHeapWalkConte...
    method dump_chunks_heap (line 6719) | def dump_chunks_heap(self, start: int, end: int, arena: GlibcArena, ct...
    method should_process_chunk (line 6764) | def should_process_chunk(self, chunk: GlibcChunk, ctx: GlibcHeapWalkCo...
  class GlibcHeapBinsCommand (line 6775) | class GlibcHeapBinsCommand(GenericCommand):
    method __init__ (line 6783) | def __init__(self) -> None:
    method do_invoke (line 6788) | def do_invoke(self, argv: list[str]) -> None:
    method pprint_bin (line 6802) | def pprint_bin(self, arena_addr: str, index: int, _type: str = "") -> ...
  class GlibcHeapTcachebinsCommand (line 6837) | class GlibcHeapTcachebinsCommand(GenericCommand):
    method __init__ (line 6846) | def __init__(self) -> None:
    method do_invoke (line 6851) | def do_invoke(self, argv: list[str]) -> None:
    method find_tcache (line 6930) | def find_tcache(self) -> int:
    method check_thread_ids (line 6948) | def check_thread_ids(self, tids: list[int]) -> list[int]:
    method tcachebin (line 6953) | def tcachebin(self, tcache_base: int, i: int) -> tuple[GlibcTcacheChun...
  class GlibcHeapFastbinsYCommand (line 6989) | class GlibcHeapFastbinsYCommand(GenericCommand):
    method __init__ (line 6996) | def __init__(self) -> None:
    method do_invoke (line 7002) | def do_invoke(self, *_: Any, **kwargs: Any) -> None:
  class GlibcHeapUnsortedBinsCommand (line 7055) | class GlibcHeapUnsortedBinsCommand(GenericCommand):
    method __init__ (line 7062) | def __init__(self) -> None:
    method do_invoke (line 7068) | def do_invoke(self, *_: Any, **kwargs: Any) -> None:
  class GlibcHeapSmallBinsCommand (line 7085) | class GlibcHeapSmallBinsCommand(GenericCommand):
    method __init__ (line 7091) | def __init__(self) -> None:
    method do_invoke (line 7097) | def do_invoke(self, *_: Any, **kwargs: Any) -> None:
  class GlibcHeapLargeBinsCommand (line 7119) | class GlibcHeapLargeBinsCommand(GenericCommand):
    method __init__ (line 7125) | def __init__(self) -> None:
    method do_invoke (line 7131) | def do_invoke(self, *_: Any, **kwargs: Any) -> None:
  class DetailRegistersCommand (line 7153) | class DetailRegistersCommand(GenericCommand):
    method do_invoke (line 7163) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class ShellcodeCommand (line 7247) | class ShellcodeCommand(GenericCommand):
    method __init__ (line 7254) | def __init__(self) -> None:
    method do_invoke (line 7258) | def do_invoke(self, _: list[str]) -> None:
  class ShellcodeSearchCommand (line 7265) | class ShellcodeSearchCommand(GenericCommand):
    method do_invoke (line 7275) | def do_invoke(self, argv: list[str]) -> None:
  class ShellcodeGetCommand (line 7310) | class ShellcodeGetCommand(GenericCommand):
    method do_invoke (line 7320) | def do_invoke(self, argv: list[str]) -> None:
    method get_shellcode (line 7334) | def get_shellcode(self, sid: int) -> None:
  class ProcessListingCommand (line 7351) | class ProcessListingCommand(GenericCommand):
    method __init__ (line 7360) | def __init__(self) -> None:
    method do_invoke (line 7366) | def do_invoke(self, _: list, **kwargs: Any) -> None:
    method get_processes (line 7396) | def get_processes(self) -> Generator[dict[str, str], None, None]:
  class ElfInfoCommand (line 7416) | class ElfInfoCommand(GenericCommand):
    method __init__ (line 7424) | def __init__(self) -> None:
    method do_invoke (line 7429) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class EntryPointBreakCommand (line 7494) | class EntryPointBreakCommand(GenericCommand):
    method __init__ (line 7503) | def __init__(self) -> None:
    method do_invoke (line 7508) | def do_invoke(self, argv: list[str]) -> None:
    method set_init_tbreak (line 7557) | def set_init_tbreak(self, addr: int) -> EntryBreakBreakpoint:
    method set_init_tbreak_pie (line 7562) | def set_init_tbreak_pie(self, addr: int, argv: list[str]) -> EntryBrea...
  class NamedBreakpointCommand (line 7575) | class NamedBreakpointCommand(GenericCommand):
    method __init__ (line 7583) | def __init__(self) -> None:
    method do_invoke (line 7588) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class ContextCommand (line 7600) | class ContextCommand(GenericCommand):
    method __init__ (line 7612) | def __init__(self) -> None:
    method post_load (line 7654) | def post_load(self) -> None:
    method show_legend (line 7659) | def show_legend(self) -> None:
    method do_invoke (line 7671) | def do_invoke(self, argv: list[str]) -> None:
    method context_title (line 7721) | def context_title(self, m: str | None) -> None:
    method context_regs (line 7744) | def context_regs(self) -> None:
    method context_stack (line 7815) | def context_stack(self) -> None:
    method addr_has_breakpoint (line 7834) | def addr_has_breakpoint(self, address: int, bp_locations: list[str]) -...
    method context_code (line 7837) | def context_code(self) -> None:
    method context_args (line 7912) | def context_args(self) -> None:
    method print_arguments_from_symbol (line 7950) | def print_arguments_from_symbol(self, function_name: str, symbol: "gdb...
    method print_guessed_arguments (line 7972) | def print_guessed_arguments(self, function_name: str) -> None:
    method line_has_breakpoint (line 8037) | def line_has_breakpoint(self, file_name: str, line_number: int, bp_loc...
    method context_source (line 8041) | def context_source(self) -> None:
    method get_pc_context_info (line 8102) | def get_pc_context_info(self, pc: int, line: str) -> str:
    method context_trace (line 8135) | def context_trace(self) -> None:
    method context_threads (line 8202) | def context_threads(self) -> None:
    method context_additional_information (line 8271) | def context_additional_information(self) -> None:
    method context_memory (line 8283) | def context_memory(self) -> None:
    method update_registers (line 8293) | def update_registers(cls, _) -> None:
    method empty_extra_messages (line 8301) | def empty_extra_messages(self, _) -> None:
  class MemoryCommand (line 8307) | class MemoryCommand(GenericCommand):
    method __init__ (line 8312) | def __init__(self) -> None:
    method do_invoke (line 8317) | def do_invoke(self, argv: list[str]) -> None:
  class MemoryWatchCommand (line 8323) | class MemoryWatchCommand(GenericCommand):
    method __init__ (line 8330) | def __init__(self) -> None:
    method do_invoke (line 8335) | def do_invoke(self, argv: list[str]) -> None:
  class MemoryUnwatchCommand (line 8362) | class MemoryUnwatchCommand(GenericCommand):
    method __init__ (line 8369) | def __init__(self) -> None:
    method do_invoke (line 8374) | def do_invoke(self, argv: list[str]) -> None:
  class MemoryWatchResetCommand (line 8389) | class MemoryWatchResetCommand(GenericCommand):
    method do_invoke (line 8395) | def do_invoke(self, _: list[str]) -> None:
  class MemoryWatchListCommand (line 8402) | class MemoryWatchListCommand(GenericCommand):
    method do_invoke (line 8408) | def do_invoke(self, _: list[str]) -> None:
  class HexdumpCommand (line 8420) | class HexdumpCommand(GenericCommand):
    method __init__ (line 8427) | def __init__(self) -> None:
    method do_invoke (line 8436) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
    method _hexdump (line 8463) | def _hexdump(self, start_addr: int, length: int, arrange_as: str, offs...
  class HexdumpQwordCommand (line 8498) | class HexdumpQwordCommand(HexdumpCommand):
    method __init__ (line 8505) | def __init__(self) -> None:
  class HexdumpDwordCommand (line 8512) | class HexdumpDwordCommand(HexdumpCommand):
    method __init__ (line 8519) | def __init__(self) -> None:
  class HexdumpWordCommand (line 8526) | class HexdumpWordCommand(HexdumpCommand):
    method __init__ (line 8533) | def __init__(self) -> None:
  class HexdumpByteCommand (line 8540) | class HexdumpByteCommand(HexdumpCommand):
    method __init__ (line 8547) | def __init__(self) -> None:
  class PatchCommand (line 8554) | class PatchCommand(GenericCommand):
    method __init__ (line 8567) | def __init__(self) -> None:
    method do_invoke (line 8574) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class PatchQwordCommand (line 8607) | class PatchQwordCommand(PatchCommand):
    method __init__ (line 8614) | def __init__(self) -> None:
  class PatchDwordCommand (line 8621) | class PatchDwordCommand(PatchCommand):
    method __init__ (line 8628) | def __init__(self) -> None:
  class PatchWordCommand (line 8635) | class PatchWordCommand(PatchCommand):
    method __init__ (line 8642) | def __init__(self) -> None:
  class PatchByteCommand (line 8649) | class PatchByteCommand(PatchCommand):
    method __init__ (line 8656) | def __init__(self) -> None:
  class PatchStringCommand (line 8663) | class PatchStringCommand(GenericCommand):
    method do_invoke (line 8674) | def do_invoke(self, argv: list[str]) -> None:
  function dereference_from (line 8692) | def dereference_from(address: int) -> list[str]:
  class DereferenceCommand (line 8754) | class DereferenceCommand(GenericCommand):
    method __init__ (line 8763) | def __init__(self) -> None:
    method pprint_dereferenced (line 8769) | def pprint_dereferenced(addr: int, idx: int, base_offset: int = 0) -> ...
    method do_invoke (line 8802) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class ASLRCommand (line 8849) | class ASLRCommand(GenericCommand):
    method do_invoke (line 8856) | def do_invoke(self, argv: list[str]) -> None:
  class ResetCacheCommand (line 8891) | class ResetCacheCommand(GenericCommand):
    method do_invoke (line 8898) | def do_invoke(self, _: list[str]) -> None:
  class VMMapCommand (line 8904) | class VMMapCommand(GenericCommand):
    method do_invoke (line 8914) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
    method format_addr_filter (line 8971) | def format_addr_filter(self, arg: str, addr: int):
    method print_entry (line 8974) | def print_entry(self, entry: Section) -> None:
    method show_legend (line 8999) | def show_legend(self) -> None:
    method is_integer (line 9006) | def is_integer(self, n: str) -> bool:
  class XFilesCommand (line 9015) | class XFilesCommand(GenericCommand):
    method do_invoke (line 9026) | def do_invoke(self, argv: list[str]) -> None:
  class XAddressInfoCommand (line 9052) | class XAddressInfoCommand(GenericCommand):
    method __init__ (line 9059) | def __init__(self) -> None:
    method do_invoke (line 9064) | def do_invoke(self, argv: list[str]) -> None:
    method infos (line 9080) | def infos(self, address: int) -> None:
  class XorMemoryCommand (line 9114) | class XorMemoryCommand(GenericCommand):
    method __init__ (line 9121) | def __init__(self) -> None:
    method do_invoke (line 9125) | def do_invoke(self, _: list[str]) -> None:
  class XorMemoryDisplayCommand (line 9131) | class XorMemoryDisplayCommand(GenericCommand):
    method do_invoke (line 9140) | def do_invoke(self, argv: list[str]) -> None:
  class XorMemoryPatchCommand (line 9160) | class XorMemoryPatchCommand(GenericCommand):
    method do_invoke (line 9169) | def do_invoke(self, argv: list[str]) -> None:
  class TraceRunCommand (line 9185) | class TraceRunCommand(GenericCommand):
    method __init__ (line 9194) | def __init__(self) -> None:
    method do_invoke (line 9201) | def do_invoke(self, argv: list[str]) -> None:
    method get_frames_size (line 9221) | def get_frames_size(self) -> int:
    method trace (line 9229) | def trace(self, loc_start: int, loc_end: int, depth: int) -> None:
    method start_tracing (line 9240) | def start_tracing(self, loc_start: int, loc_end: int, depth: int) -> N...
  class PatternCommand (line 9275) | class PatternCommand(GenericCommand):
    method __init__ (line 9283) | def __init__(self) -> None:
    method do_invoke (line 9288) | def do_invoke(self, _: list[str]) -> None:
  class PatternCreateCommand (line 9294) | class PatternCreateCommand(GenericCommand):
    method do_invoke (line 9307) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
  class PatternSearchCommand (line 9319) | class PatternSearchCommand(GenericCommand):
    method do_invoke (line 9334) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
    method search (line 9348) | def search(self, pattern: str, size: int, period: int) -> None:
  class ChecksecCommand (line 9386) | class ChecksecCommand(GenericCommand):
    method __init__ (line 9399) | def __init__(self) -> None:
    method do_invoke (line 9403) | def do_invoke(self, argv: list[str]) -> None:
    method print_security_properties (line 9424) | def print_security_properties(self, filename: str) -> None:
  class GotCommand (line 9446) | class GotCommand(GenericCommand):
    method __init__ (line 9453) | def __init__(self):
    method build_line (line 9461) | def build_line(self, name: str, _path: str, color: str, address_val: i...
    method do_invoke (line 9468) | def do_invoke(self, _: list[str], **kwargs: Any) -> None:
    method print_got_for (line 9478) | def print_got_for(self, file: str, realpath: str, argv: list[str]) -> ...
  class HighlightCommand (line 9537) | class HighlightCommand(GenericCommand):
    method __init__ (line 9543) | def __init__(self) -> None:
    method do_invoke (line 9547) | def do_invoke(self, _: list[str]) -> None:
  class HighlightListCommand (line 9552) | class HighlightListCommand(GenericCommand):
    method print_highlight_table (line 9558) | def print_highlight_table(self) -> None:
    method do_invoke (line 9569) | def do_invoke(self, _: list[str]) -> None:
  class HighlightClearCommand (line 9574) | class HighlightClearCommand(GenericCommand):
    method do_invoke (line 9580) | def do_invoke(self, _: list[str]) -> None:
  class HighlightAddCommand (line 9585) | class HighlightAddCommand(GenericCommand):
    method do_invoke (line 9592) | def do_invoke(self, argv: list[str]) -> None:
  class HighlightRemoveCommand (line 9602) | class HighlightRemoveCommand(GenericCommand):
    method do_invoke (line 9615) | def do_invoke(self, argv: list[str]) -> None:
  class FormatStringSearchCommand (line 9624) | class FormatStringSearchCommand(GenericCommand):
    method do_invoke (line 9633) | def do_invoke(self, _: list[str]) -> None:
  class HeapAnalysisCommand (line 9656) | class HeapAnalysisCommand(GenericCommand):
    method __init__ (line 9667) | def __init__(self) -> None:
    method do_invoke (line 9683) | def do_invoke(self, argv: list[str]) -> None:
    method setup (line 9692) | def setup(self) -> None:
    method dump_tracked_allocations (line 9713) | def dump_tracked_allocations(self) -> None:
    method clean (line 9731) | def clean(self, _: "gdb.ExitedEvent") -> None:
  function register_function (line 9764) | def register_function(cls: Type["GenericFunction"]) -> Type["GenericFunc...
  class GenericFunction (line 9769) | class GenericFunction(gdb.Function):
    method __init__ (line 9776) | def __init__(self) -> None:
    method invoke (line 9779) | def invoke(self, *args: Any) -> int:
    method arg_to_long (line 9784) | def arg_to_long(self, args: Any, index: int, default: int = 0) -> int:
    method do_invoke (line 9791) | def do_invoke(self, args: Any) -> int:
  class StackOffsetFunction (line 9796) | class StackOffsetFunction(GenericFunction):
    method do_invoke (line 9801) | def do_invoke(self, args: list) -> int:
  class HeapBaseFunction (line 9810) | class HeapBaseFunction(GenericFunction):
    method do_invoke (line 9815) | def do_invoke(self, args: list[str]) -> int:
  class SectionBaseFunction (line 9825) | class SectionBaseFunction(GenericFunction):
    method do_invoke (line 9832) | def do_invoke(self, args: list) -> int:
  class BssBaseFunction (line 9854) | class BssBaseFunction(GenericFunction):
    method do_invoke (line 9860) | def do_invoke(self, args: list) -> int:
  class GotBaseFunction (line 9868) | class GotBaseFunction(GenericFunction):
    method do_invoke (line 9874) | def do_invoke(self, args: list) -> int:
  class GefFunctionsCommand (line 9882) | class GefFunctionsCommand(GenericCommand):
    method __init__ (line 9887) | def __init__(self) -> None:
    method __add__ (line 9893) | def __add__(self, function: GenericFunction):
    method __radd__ (line 9906) | def __radd__(self, function: GenericFunction):
    method __str__ (line 9909) | def __str__(self) -> str:
    method __rebuild (line 9914) | def __rebuild(self) -> None:
    method do_invoke (line 9926) | def do_invoke(self, argv) -> None:
  class GefCommand (line 9938) | class GefCommand(gdb.Command):
    method __init__ (line 9944) | def __init__(self) -> None:
    method loaded_commands (line 9970) | def loaded_commands(self) -> list[tuple[str, Type[GenericCommand], Any]]:
    method loaded_functions (line 9975) | def loaded_functions(self) -> list[Type[GenericFunction]]:
    method missing_commands (line 9980) | def missing_commands(self) -> dict[str, Exception]:
    method setup (line 9983) | def setup(self) -> None:
    method load_extra_plugins (line 9999) | def load_extra_plugins(self, extra_plugins_dir: pathlib.Path | None = ...
    method loaded_command_names (line 10044) | def loaded_command_names(self) -> Iterable[str]:
    method invoke (line 10048) | def invoke(self, args: Any, from_tty: bool) -> None:
    method add_context_layout_mapping (line 10053) | def add_context_layout_mapping(self, current_pane_name: str, display_p...
    method add_context_pane (line 10061) | def add_context_pane(self, pane_name: str, display_pane_function: Call...
    method load (line 10072) | def load(self) -> None:
    method show_banner (line 10113) | def show_banner(self) -> None:
  class GefHelpCommand (line 10132) | class GefHelpCommand(gdb.Command):
    method __init__ (line 10137) | def __init__(self) -> None:
    method invoke (line 10144) | def invoke(self, args: Any, from_tty: bool) -> None:
    method __rebuild (line 10150) | def __rebuild(self) -> None:
    method __add__ (line 10162) | def __add__(self, command: tuple[str, GenericCommand]):
    method __radd__ (line 10174) | def __radd__(self, command: tuple[str, GenericCommand]):
    method __str__ (line 10177) | def __str__(self) -> str:
  class GefConfigCommand (line 10185) | class GefConfigCommand(gdb.Command):
    method __init__ (line 10195) | def __init__(self) -> None:
    method invoke (line 10199) | def invoke(self, args: str, from_tty: bool) -> None:
    method print_setting (line 10235) | def print_setting(self, plugin_name: str, verbose: bool = False) -> None:
    method print_settings (line 10257) | def print_settings(self) -> None:
    method set_setting (line 10262) | def set_setting(self, argv: list[str]) -> bool:
    method complete (line 10298) | def complete(self, text: str, word: str) -> list[str]:
  class GefSaveCommand (line 10313) | class GefSaveCommand(gdb.Command):
    method __init__ (line 10319) | def __init__(self) -> None:
    method invoke (line 10323) | def invoke(self, args: Any, from_tty: bool) -> None:
  class GefRestoreCommand (line 10351) | class GefRestoreCommand(gdb.Command):
    method __init__ (line 10357) | def __init__(self) -> None:
    method invoke (line 10362) | def invoke(self, args: str, from_tty: bool) -> None:
    method reload (line 10369) | def reload(self, quiet: bool):
  class GefMissingCommand (line 10400) | class GefMissingCommand(gdb.Command):
    method __init__ (line 10408) | def __init__(self) -> None:
    method invoke (line 10412) | def invoke(self, args: Any, from_tty: bool) -> None:
  class GefSetCommand (line 10424) | class GefSetCommand(gdb.Command):
    method __init__ (line 10429) | def __init__(self) -> None:
    method invoke (line 10433) | def invoke(self, args: Any, from_tty: bool) -> None:
  class GefRunCommand (line 10448) | class GefRunCommand(gdb.Command):
    method __init__ (line 10454) | def __init__(self) -> None:
    method invoke (line 10458) | def invoke(self, args: Any, from_tty: bool) -> None:
  class GefAlias (line 10470) | class GefAlias(gdb.Command):
    method __init__ (line 10473) | def __init__(self, alias: str, command: str, completer_class: int = gd...
    method __repr__ (line 10497) | def __repr__(self) -> str:
    method __str__ (line 10500) | def __str__(self) -> str:
    method invoke (line 10503) | def invoke(self, args: Any, from_tty: bool) -> None:
    method lookup_command (line 10507) | def lookup_command(self, cmd: str) -> tuple[str, GenericCommand] | None:
  class AliasesCommand (line 10517) | class AliasesCommand(GenericCommand):
    method __init__ (line 10523) | def __init__(self) -> None:
    method do_invoke (line 10527) | def do_invoke(self, _: list[str]) -> None:
  class AliasesAddCommand (line 10533) | class AliasesAddCommand(AliasesCommand):
    method __init__ (line 10540) | def __init__(self) -> None:
    method do_invoke (line 10544) | def do_invoke(self, argv: list[str]) -> None:
  class AliasesRmCommand (line 10553) | class AliasesRmCommand(AliasesCommand):
    method __init__ (line 10559) | def __init__(self) -> None:
    method do_invoke (line 10563) | def do_invoke(self, argv: list[str]) -> None:
  class AliasesListCommand (line 10579) | class AliasesListCommand(AliasesCommand):
    method __init__ (line 10585) | def __init__(self) -> None:
    method do_invoke (line 10589) | def do_invoke(self, _: list[str]) -> None:
  class GefTmuxSetup (line 10596) | class GefTmuxSetup(gdb.Command):
    method __init__ (line 10599) | def __init__(self) -> None:
    method invoke (line 10604) | def invoke(self, args: Any, from_tty: bool) -> None:
    method tmux_setup (line 10620) | def tmux_setup(self) -> None:
    method screen_setup (line 10637) | def screen_setup(self) -> None:
  class GefInstallExtraScriptCommand (line 10666) | class GefInstallExtraScriptCommand(gdb.Command):
    method __init__ (line 10672) | def __init__(self) -> None:
    method invoke (line 10677) | def invoke(self, argv: str, from_tty: bool) -> None:
    method __install_extras_script (line 10701) | def __install_extras_script(self, script: str) -> bool:
  function __gef_prompt__ (line 10727) | def __gef_prompt__(current_prompt: Callable[[Callable], str]) -> str:
  class GefManager (line 10737) | class GefManager(metaclass=abc.ABCMeta):
    method reset_caches (line 10738) | def reset_caches(self) -> None:
  class GefMemoryManager (line 10752) | class GefMemoryManager(GefManager):
    method __init__ (line 10754) | def __init__(self) -> None:
    method reset_caches (line 10758) | def reset_caches(self) -> None:
    method write (line 10763) | def write(self, address: int, buffer: ByteString, length: int | None =...
    method read (line 10768) | def read(self, addr: int, length: int = 0x10) -> bytes:
    method read_integer (line 10772) | def read_integer(self, addr: int) -> int:
    method read_cstring (line 10779) | def read_cstring(self,
    method read_ascii_string (line 10823) | def read_ascii_string(self, address: int) -> str | None:
    method maps (line 10831) | def maps(self) -> list[Section]:
    method __parse_maps (line 10839) | def __parse_maps(self) -> list[Section] | None:
    method parse_procfs_maps (line 10871) | def parse_procfs_maps() -> Generator[Section, None, None]:
    method parse_gdb_info_proc_maps (line 10903) | def parse_gdb_info_proc_maps() -> Generator[Section, None, None]:
    method parse_monitor_info_mem (line 10962) | def parse_monitor_info_mem() -> Generator[Section, None, None]:
    method parse_gdb_maintenance_info_sections (line 10984) | def parse_gdb_maintenance_info_sections() -> Generator[Section, None, ...
    method parse_info_mem (line 11017) | def parse_info_mem():
    method append (line 11037) | def append(self, section: Section):
    method __iadd__ (line 11050) | def __iadd__(self, section: Section):
  class GefHeapManager (line 11054) | class GefHeapManager(GefManager):
    method __init__ (line 11056) | def __init__(self) -> None:
    method reset_caches (line 11060) | def reset_caches(self) -> None:
    method main_arena (line 11067) | def main_arena(self) -> GlibcArena | None:
    method main_arena (line 11081) | def main_arena(self, value: GlibcArena) -> None:
    method find_main_arena_addr (line 11087) | def find_main_arena_addr() -> int:
    method selected_arena (line 11163) | def selected_arena(self) -> GlibcArena | None:
    method selected_arena (line 11170) | def selected_arena(self, value: GlibcArena) -> None:
    method arenas (line 11175) | def arenas(self) -> list | Iterator[GlibcArena]:
    method base_address (line 11181) | def base_address(self) -> int | None:
    method chunks (line 11196) | def chunks(self) -> list | Iterator:
    method min_chunk_size (line 11202) | def min_chunk_size(self) -> int:
    method malloc_alignment (line 11206) | def malloc_alignment(self) -> int:
    method csize2tidx (line 11217) | def csize2tidx(self, size: int) -> int:
    method tidx2size (line 11220) | def tidx2size(self, idx: int) -> int:
    method malloc_align_address (line 11223) | def malloc_align_address(self, address: int) -> int:
  class GefSetting (line 11231) | class GefSetting:
    method __init__ (line 11234) | def __init__(self, value: Any, cls: type | None = None, description: s...
    method __str__ (line 11246) | def __str__(self) -> str:
    method add_hook (line 11251) | def add_hook(self, access: str, funcs: list[Callable]):
    method no_spaces (line 11261) | def no_spaces(value: pathlib.Path):
    method must_exist (line 11266) | def must_exist(value: pathlib.Path):
    method create_folder_tree (line 11271) | def create_folder_tree(value: pathlib.Path):
  class GefSettingsManager (line 11275) | class GefSettingsManager(dict):
    method __getitem__ (line 11280) | def __getitem__(self, name: str) -> Any:
    method __setitem__ (line 11285) | def __setitem__(self, name: str, value: Any) -> None:
    method __delitem__ (line 11308) | def __delitem__(self, name: str) -> None:
    method raw_entry (line 11311) | def raw_entry(self, name: str) -> GefSetting:
    method __invoke_read_hooks (line 11314) | def __invoke_read_hooks(self, setting: GefSetting) -> None:
    method __invoke_changed_hooks (line 11319) | def __invoke_changed_hooks(self, setting: GefSetting, new_value: Any) ...
    method __invoke_write_hooks (line 11326) | def __invoke_write_hooks(self, setting: GefSetting, new_value: Any) ->...
  class GefSessionManager (line 11331) | class GefSessionManager(GefManager):
    method __init__ (line 11333) | def __init__(self) -> None:
    method reset_caches (line 11352) | def reset_caches(self) -> None:
    method __str__ (line 11363) | def __str__(self) -> str:
    method __repr__ (line 11367) | def __repr__(self) -> str:
    method auxiliary_vector (line 11371) | def auxiliary_vector(self) -> dict[str, int] | None:
    method os (line 11394) | def os(self) -> str:
    method pid (line 11401) | def pid(self) -> int:
    method file (line 11411) | def file(self) -> pathlib.Path | None:
    method cwd (line 11423) | def cwd(self) -> pathlib.Path | None:
    method pagesize (line 11429) | def pagesize(self) -> int:
    method canary (line 11438) | def canary(self) -> tuple[int, int] | None:
    method original_canary (line 11452) | def original_canary(self) -> tuple[int, int] | None:
    method maps (line 11464) | def maps(self) -> pathlib.Path | None:
    method root (line 11476) | def root(self) -> pathlib.Path | None:
  class GefRemoteSessionManager (line 11485) | class GefRemoteSessionManager(GefSessionManager):
    class RemoteMode (line 11489) | class RemoteMode(enum.IntEnum):
      method __str__ (line 11494) | def __str__(self):
      method __repr__ (line 11497) | def __repr__(self):
      method prompt_string (line 11500) | def prompt_string(self) -> str:
    method __init__ (line 11510) | def __init__(self, host: str, port: int, pid: int =-1, qemu: pathlib.P...
    method close (line 11527) | def close(self) -> None:
    method __str__ (line 11536) | def __str__(self) -> str:
    method __repr__ (line 11539) | def __repr__(self) -> str:
    method target (line 11543) | def target(self) -> str:
    method root (line 11547) | def root(self) -> pathlib.Path:
    method file (line 11551) | def file(self) -> pathlib.Path:
    method lfile (line 11565) | def lfile(self) -> pathlib.Path:
    method maps (line 11570) | def maps(self) -> pathlib.Path:
    method mode (line 11576) | def mode(self) -> RemoteMode:
    method sync (line 11579) | def sync(self, src: str, dst: str | None = None) -> bool:
    method connect (line 11592) | def connect(self, pid: int) -> bool:
    method setup (line 11621) | def setup(self) -> bool:
    method __setup_qemu (line 11642) | def __setup_qemu(self) -> bool:
    method __setup_remote (line 11676) | def __setup_remote(self) -> bool:
    method __setup_rr (line 11692) | def __setup_rr(self) -> bool:
    method remote_objfile_event_handler (line 11700) | def remote_objfile_event_handler(self, evt: "gdb.NewObjFileEvent") -> ...
  class GefUiManager (line 11714) | class GefUiManager(GefManager):
    method __init__ (line 11716) | def __init__(self) -> None:
  class GefLibcManager (line 11726) | class GefLibcManager(GefManager):
    method __init__ (line 11731) | def __init__(self) -> None:
    method __str__ (line 11737) | def __str__(self) -> str:
    method version (line 11741) | def version(self) -> tuple[int, int] | None:
    method find_libc_version (line 11759) | def find_libc_version() -> tuple[int, int]:
  class Gef (line 11780) | class Gef:
    method __init__ (line 11793) | def __init__(self) -> None:
    method __str__ (line 11802) | def __str__(self) -> str:
    method reinitialize_managers (line 11805) | def reinitialize_managers(self) -> None:
    method setup (line 11812) | def setup(self) -> None:
    method reset_caches (line 11820) | def reset_caches(self) -> None:
  function target_remote_posthook (line 11828) | def target_remote_posthook():

FILE: get-pip.py
  function include_setuptools (line 46) | def include_setuptools(args):
  function include_wheel (line 57) | def include_wheel(args):
  function determine_pip_install_arguments (line 68) | def determine_pip_install_arguments():
  function monkeypatch_for_cert (line 85) | def monkeypatch_for_cert(tmpdir):
  function bootstrap (line 112) | def bootstrap(tmpdir):
  function main (line 122) | def main():

FILE: scripts/new-release.py
  function dbg (line 36) | def dbg(x: str):
  function shell (line 42) | def shell(x: str) -> str:
  function generate_changelog (line 47) | def generate_changelog(args: argparse.Namespace) -> bool:
  function test_token (line 126) | def test_token(args) -> bool:

FILE: scripts/remote_debug.py
  class RemoteDebugService (line 10) | class RemoteDebugService(rpyc.Service):
    method on_connect (line 11) | def on_connect(self, conn: rpyc.core.protocol.Connection):
    method on_disconnect (line 15) | def on_disconnect(self, conn: rpyc.core.protocol.Connection):
    method exposed_eval (line 19) | def exposed_eval(self, cmd):
  function start_rpyc_service (line 27) | def start_rpyc_service(port: int = RPYC_PORT):

FILE: tests/api/deprecated.py
  class GefFuncDeprecatedApi (line 11) | class GefFuncDeprecatedApi(RemoteGefUnitTestGeneric):
    method test_deprecated_elf_values (line 15) | def test_deprecated_elf_values(self):
    method test_deprecated_gef_attributes (line 35) | def test_deprecated_gef_attributes(self):

FILE: tests/api/gef_arch.py
  class GefArchApi (line 12) | class GefArchApi(RemoteGefUnitTestGeneric):
    method setUp (line 15) | def setUp(self) -> None:
    method test_api_gef_arch_ptrsize (line 19) | def test_api_gef_arch_ptrsize(self):
    method test_api_gef_arch_x86_64 (line 26) | def test_api_gef_arch_x86_64(self):
    method test_api_gef_arch_x86 (line 40) | def test_api_gef_arch_x86(self):

FILE: tests/api/gef_disassemble.py
  class GefDisassembleApiFunction (line 11) | class GefDisassembleApiFunction(RemoteGefUnitTestGeneric):
    method setUp (line 14) | def setUp(self) -> None:
    method test_func_gef_disassemble (line 19) | def test_func_gef_disassemble(self):
    method test_func_gef_disassemble_page_border (line 37) | def test_func_gef_disassemble_page_border(self):

FILE: tests/api/gef_heap.py
  class GefHeapApi (line 13) | class GefHeapApi(RemoteGefUnitTestGeneric):
    method setUp (line 16) | def setUp(self) -> None:
    method valid_sizes (line 40) | def valid_sizes(self):
    method test_func_gef_heap_tidx2size (line 46) | def test_func_gef_heap_tidx2size(self):
    method test_func_gef_heap_csize2tidx (line 55) | def test_func_gef_heap_csize2tidx(self):
    method test_func_gef_heap_malloc_align_address (line 65) | def test_func_gef_heap_malloc_align_address(self):
    method test_class_glibcarena_main_arena (line 80) | def test_class_glibcarena_main_arena(self):

FILE: tests/api/gef_memory.py
  class GefMemoryApi (line 21) | class GefMemoryApi(RemoteGefUnitTestGeneric):
    method setUp (line 24) | def setUp(self) -> None:
    method test_api_gef_memory_only_running (line 28) | def test_api_gef_memory_only_running(self):
    method test_api_gef_memory_parse_info_proc_maps_expected_format (line 37) | def test_api_gef_memory_parse_info_proc_maps_expected_format(self):
    method test_api_gef_memory_parse_info_proc_maps (line 68) | def test_api_gef_memory_parse_info_proc_maps(self):
    method test_func_parse_permissions (line 86) | def test_func_parse_permissions(self):
    method test_func_parse_maps_local_procfs (line 100) | def test_func_parse_maps_local_procfs(self):
    method test_func_parse_maps_remote_gdbserver (line 123) | def test_func_parse_maps_remote_gdbserver(self):
    method test_func_parse_maps_remote_qemu (line 141) | def test_func_parse_maps_remote_qemu(self):
    method test_func_parse_maps_realpath (line 157) | def test_func_parse_maps_realpath(self):
    method test_func_read_cstring_oob (line 184) | def test_func_read_cstring_oob(self):

FILE: tests/api/gef_session.py
  class GefSessionApi (line 22) | class GefSessionApi(RemoteGefUnitTestGeneric):
    method setUp (line 25) | def setUp(self) -> None:
    method test_func_get_filepath (line 29) | def test_func_get_filepath(self):
    method test_func_get_pid (line 35) | def test_func_get_pid(self):
    method test_func_auxiliary_vector (line 44) | def test_func_auxiliary_vector(self):
    method test_root_dir_local (line 53) | def test_root_dir_local(self):
    method test_root_dir_remote (line 63) | def test_root_dir_remote(self):
    method test_root_dir_qemu (line 78) | def test_root_dir_qemu(self):

FILE: tests/api/misc.py
  class MiscFunctionTest (line 16) | class MiscFunctionTest(RemoteGefUnitTestGeneric):
    method setUp (line 19) | def setUp(self) -> None:
    method test_func_which (line 23) | def test_func_which(self):
    method test_func_gef_convenience (line 33) | def test_func_gef_convenience(self):
    method test_func_parse_address (line 37) | def test_func_parse_address(self):
    method test_func_show_last_exception (line 44) | def test_func_show_last_exception(self):
    method test_func_process_lookup_path (line 69) | def test_func_process_lookup_path(self):

FILE: tests/base.py
  class RemoteGefUnitTestGeneric (line 24) | class RemoteGefUnitTestGeneric(unittest.TestCase):
    method setUp (line 30) | def setUp(self) -> None:
    method __setup (line 51) | def __setup(self):
    method tearDown (line 103) | def tearDown(self) -> None:
    method gdb_version (line 112) | def gdb_version(self) -> tuple[int, int]:

FILE: tests/binaries/bss.c
  function main (line 15) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/canary.c
  function greetz (line 14) | void greetz(char* buf)
  function main (line 22) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/checksec-no-canary.c
  function main (line 17) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/checksec-no-nx.c
  function main (line 17) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/checksec-no-pie.c
  function main (line 17) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/class.cpp
  class TraitA (line 3) | class TraitA {}
  class TraitB (line 4) | class TraitB {}
  class A (line 6) | class A {
    method Run (line 12) | virtual void Run() { printf("I am A\n"); }
  class B (line 16) | class B : public A {
    method Run (line 21) | virtual void Run() { printf("I am B\n"); }
  function main (line 24) | int main() {

FILE: tests/binaries/collision.c
  function main (line 12) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/default.c
  function main (line 12) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/format-string-helper.c
  function greetz (line 14) | void greetz(char* buf)
  function main (line 24) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/heap-analysis.c
  function main (line 14) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/heap-bins.c
  function main (line 6) | int main(){

FILE: tests/binaries/heap-fastbins.c
  function main (line 19) | int main()

FILE: tests/binaries/heap-multiple-heaps.c
  function main (line 44) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/heap-non-main.c
  function main (line 22) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/heap-tcache.c
  function main (line 31) | int main()

FILE: tests/binaries/heap.c
  function main (line 19) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/memwatch.c
  function main (line 6) | int main(int argc, char** argv)

FILE: tests/binaries/mmap-known-address.c
  function main (line 20) | int main(int argc, char **argv, char **envp)

FILE: tests/binaries/nested.c
  function f10 (line 2) | void f10(){ DebugBreak(); }
  function f9 (line 3) | void f9(){ f10(); }
  function f8 (line 4) | void f8(){ f9(); }
  function f7 (line 5) | void f7(){ f8(); }
  function f6 (line 6) | void f6(){ f7(); }
  function f5 (line 7) | void f5(){ f6(); }
  function f4 (line 8) | void f4(){ f5(); }
  function f3 (line 9) | void f3(){ f4(); }
  function f2 (line 10) | void f2(){ f3(); }
  function f1 (line 11) | void f1(){ f2(); }
  function main (line 12) | int main(){ f1(); return 0;}

FILE: tests/binaries/nested2.c
  function f1 (line 2) | int f1(int i){ if(i==10) {DebugBreak(); return 0;} return f1(++i); }
  function main (line 3) | int main(){ return f1(0); }

FILE: tests/binaries/pattern.c
  function greetz (line 14) | void greetz(char* buf)
  function main (line 22) | int main(int argc, char** argv, char** envp)

FILE: tests/binaries/pcustom.c
  type foo_t (line 8) | struct foo_t {
  type goo_t (line 13) | struct goo_t {
  function main (line 21) | int main()

FILE: tests/commands/aliases.py
  class AliasesCommand (line 8) | class AliasesCommand(RemoteGefUnitTestGeneric):
    method test_cmd_aliases_add (line 11) | def test_cmd_aliases_add(self):
    method test_cmd_aliases_list (line 19) | def test_cmd_aliases_list(self):
    method test_cmd_aliases_rm (line 32) | def test_cmd_aliases_rm(self):

FILE: tests/commands/arch.py
  class ArchCommand (line 11) | class ArchCommand(RemoteGefUnitTestGeneric):
    method test_cmd_arch_get (line 15) | def test_cmd_arch_get(self):
    method test_cmd_arch_set (line 22) | def test_cmd_arch_set(self):
    method test_cmd_arch_list (line 38) | def test_cmd_arch_list(self):

FILE: tests/commands/aslr.py
  class AslrCommand (line 9) | class AslrCommand(RemoteGefUnitTestGeneric):
    method __is_alsr_on_gdb (line 14) | def __is_alsr_on_gdb(self):
    method test_cmd_aslr_show (line 19) | def test_cmd_aslr_show(self):
    method test_cmd_aslr_toggle (line 30) | def test_cmd_aslr_toggle(self):

FILE: tests/commands/canary.py
  class CanaryCommand (line 9) | class CanaryCommand(RemoteGefUnitTestGeneric):
    method setUp (line 12) | def setUp(self) -> None:
    method test_cmd_canary (line 16) | def test_cmd_canary(self):
    method test_overwrite_canary (line 23) | def test_overwrite_canary(self):

FILE: tests/commands/checksec.py
  class ChecksecCommandNoCanary (line 9) | class ChecksecCommandNoCanary(RemoteGefUnitTestGeneric):
    method setUp (line 12) | def setUp(self) -> None:
    method test_cmd_checksec (line 16) | def test_cmd_checksec(self):
  class ChecksecCommandNoNx (line 24) | class ChecksecCommandNoNx(RemoteGefUnitTestGeneric):
    method setUp (line 25) | def setUp(self) -> None:
    method test_cmd_checksec (line 29) | def test_cmd_checksec(self):
  class ChecksecCommandNoPie (line 37) | class ChecksecCommandNoPie(RemoteGefUnitTestGeneric):
    method setUp (line 38) | def setUp(self) -> None:
    method test_cmd_checksec (line 42) | def test_cmd_checksec(self):

FILE: tests/commands/context.py
  class ContextCommand (line 9) | class ContextCommand(RemoteGefUnitTestGeneric):
    method test_duplicate_pane_name (line 18) | def test_duplicate_pane_name(self):

FILE: tests/commands/dereference.py
  class DereferenceCommand (line 9) | class DereferenceCommand(RemoteGefUnitTestGeneric):
    method test_cmd_dereference (line 12) | def test_cmd_dereference(self):
    method test_cmd_dereference_forwards (line 27) | def test_cmd_dereference_forwards(self):
    method test_cmd_dereference_backwards (line 56) | def test_cmd_dereference_backwards(self):

FILE: tests/commands/edit_flags.py
  class EditFlagsCommand (line 13) | class EditFlagsCommand(RemoteGefUnitTestGeneric):
    method test_cmd_edit_flags_disable (line 16) | def test_cmd_edit_flags_disable(self):
    method test_cmd_edit_flags_enable (line 33) | def test_cmd_edit_flags_enable(self):
    method test_cmd_edit_flags_toggle (line 43) | def test_cmd_edit_flags_toggle(self):

FILE: tests/commands/elf_info.py
  class ElfInfoCommand (line 9) | class ElfInfoCommand(RemoteGefUnitTestGeneric):
    method test_cmd_elf_info (line 13) | def test_cmd_elf_info(self):

FILE: tests/commands/entry_break.py
  class EntryBreakCommand (line 9) | class EntryBreakCommand(RemoteGefUnitTestGeneric):
    method test_cmd_entry_break (line 12) | def test_cmd_entry_break(self):

FILE: tests/commands/format_string_helper.py
  class FormatStringHelperCommand (line 10) | class FormatStringHelperCommand(RemoteGefUnitTestGeneric):
    method setUp (line 13) | def setUp(self) -> None:
    method test_cmd_format_string_helper (line 17) | def test_cmd_format_string_helper(self):

FILE: tests/commands/functions.py
  class FunctionsCommand (line 9) | class FunctionsCommand(RemoteGefUnitTestGeneric):
    method test_cmd_functions (line 12) | def test_cmd_functions(self):

FILE: tests/commands/gef.py
  class GefCommand (line 12) | class GefCommand(RemoteGefUnitTestGeneric):
    method test_cmd_gef (line 15) | def test_cmd_gef(self):
    method test_cmd_gef_config (line 20) | def test_cmd_gef_config(self):
    method test_cmd_gef_config_get (line 40) | def test_cmd_gef_config_get(self):
    method test_cmd_gef_config_set (line 49) | def test_cmd_gef_config_set(self):
    method test_cmd_gef_help (line 59) | def test_cmd_gef_help(self):
    method test_cmd_gef_run_and_run (line 75) | def test_cmd_gef_run_and_run(self):
    method test_cmd_gef_save (line 92) | def test_cmd_gef_save(self):
    method test_cmd_gef_install (line 112) | def test_cmd_gef_install(self):

FILE: tests/commands/gef_remote.py
  class GefRemoteCommand (line 19) | class GefRemoteCommand(RemoteGefUnitTestGeneric):
    method setUp (line 22) | def setUp(self) -> None:
    method test_cmd_gef_remote_gdbserver (line 26) | def test_cmd_gef_remote_gdbserver(self):
    method test_cmd_gef_remote_qemu_user (line 44) | def test_cmd_gef_remote_qemu_user(self):
    method test_cmd_target_remote (line 61) | def test_cmd_target_remote(self):

FILE: tests/commands/got.py
  class GotCommand (line 17) | class GotCommand(RemoteGefUnitTestGeneric):
    method setUp (line 20) | def setUp(self) -> None:
    method test_cmd_got (line 25) | def test_cmd_got(self):

FILE: tests/commands/heap.py
  class HeapCommand (line 18) | class HeapCommand(RemoteGefUnitTestGeneric):
    method setUp (line 21) | def setUp(self) -> None:
    method test_cmd_heap_arenas (line 26) | def test_cmd_heap_arenas(self):
    method test_cmd_heap_set_arena (line 38) | def test_cmd_heap_set_arena(self):
    method test_cmd_heap_chunk_no_arg (line 50) | def test_cmd_heap_chunk_no_arg(self):
    method test_cmd_heap_chunk_with_number (line 61) | def test_cmd_heap_chunk_with_number(self):
    method test_cmd_heap_chunks (line 74) | def test_cmd_heap_chunks(self):
    method test_cmd_heap_chunks_summary (line 86) | def test_cmd_heap_chunks_summary(self):
    method test_cmd_heap_chunks_min_size_filter (line 99) | def test_cmd_heap_chunks_min_size_filter(self):
    method test_cmd_heap_chunks_max_size_filter (line 115) | def test_cmd_heap_chunks_max_size_filter(self):
    method test_cmd_heap_chunks_with_count (line 133) | def test_cmd_heap_chunks_with_count(self):
  class HeapCommandNonMain (line 151) | class HeapCommandNonMain(RemoteGefUnitTestGeneric):
    method setUp (line 152) | def setUp(self) -> None:
    method test_cmd_heap_chunks (line 157) | def test_cmd_heap_chunks(self):
    method test_cmd_heap_bins_non_main (line 179) | def test_cmd_heap_bins_non_main(self):
    method test_cmd_heap_bins_tcache (line 192) | def test_cmd_heap_bins_tcache(self):
  class HeapCommandMultipleHeaps (line 208) | class HeapCommandMultipleHeaps(RemoteGefUnitTestGeneric):
    method setUp (line 209) | def setUp(self) -> None:
    method test_cmd_heap_chunks_mult_heaps (line 214) | def test_cmd_heap_chunks_mult_heaps(self):
  class HeapCommandClass (line 227) | class HeapCommandClass(RemoteGefUnitTestGeneric):
    method setUp (line 228) | def setUp(self) -> None:
    method test_cmd_heap_chunks_summary_with_type_resolved (line 232) | def test_cmd_heap_chunks_summary_with_type_resolved(self):
  class HeapCommandFastBins (line 244) | class HeapCommandFastBins(RemoteGefUnitTestGeneric):
    method setUp (line 245) | def setUp(self) -> None:
    method test_cmd_heap_bins_fast (line 249) | def test_cmd_heap_bins_fast(self):
  class HeapCommandBins (line 263) | class HeapCommandBins(RemoteGefUnitTestGeneric):
    method setUp (line 264) | def setUp(self) -> None:
    method test_cmd_heap_bins_large (line 272) | def test_cmd_heap_bins_large(self):
    method test_cmd_heap_bins_small (line 282) | def test_cmd_heap_bins_small(self):
    method test_cmd_heap_bins_unsorted (line 293) | def test_cmd_heap_bins_unsorted(self):
  class HeapCommandTcache (line 303) | class HeapCommandTcache(RemoteGefUnitTestGeneric):
    method setUp (line 304) | def setUp(self) -> None:
    method test_cmd_heap_bins_tcache_all (line 311) | def test_cmd_heap_bins_tcache_all(self):

FILE: tests/commands/heap_analysis.py
  class HeapAnalysisCommand (line 10) | class HeapAnalysisCommand(RemoteGefUnitTestGeneric):
    method setUp (line 13) | def setUp(self) -> None:
    method test_cmd_heap_analysis (line 17) | def test_cmd_heap_analysis(self):

FILE: tests/commands/hexdump.py
  class HexdumpCommand (line 10) | class HexdumpCommand(RemoteGefUnitTestGeneric):
    method test_cmd_hexdump (line 14) | def test_cmd_hexdump(self):

FILE: tests/commands/highlight.py
  class HighlightCommand (line 10) | class HighlightCommand(RemoteGefUnitTestGeneric):
    method test_cmd_highlight (line 13) | def test_cmd_highlight(self):

FILE: tests/commands/hijack_fd.py
  class HijackFdCommand (line 9) | class HijackFdCommand(RemoteGefUnitTestGeneric):
    method test_cmd_hijack_fd (line 16) | def test_cmd_hijack_fd(self):

FILE: tests/commands/memory.py
  class MemoryCommand (line 12) | class MemoryCommand(RemoteGefUnitTestGeneric):
    method setUp (line 15) | def setUp(self) -> None:
    method test_cmd_memory_watch_basic (line 19) | def test_cmd_memory_watch_basic(self):
    method test_cmd_memory_watch_global_variable (line 37) | def test_cmd_memory_watch_global_variable(self):
    method test_cmd_memory_unwatch (line 67) | def test_cmd_memory_unwatch(self):
    method test_cmd_memory_list (line 76) | def test_cmd_memory_list(self):
    method test_cmd_memory_reset (line 85) | def test_cmd_memory_reset(self):

FILE: tests/commands/name_break.py
  class NameBreakCommand (line 9) | class NameBreakCommand(RemoteGefUnitTestGeneric):
    method test_cmd_name_break (line 12) | def test_cmd_name_break(self):

FILE: tests/commands/nop.py
  class NopCommand (line 21) | class NopCommand(RemoteGefUnitTestGeneric):
    method test_cmd_nop_inactive (line 26) | def test_cmd_nop_inactive(self):
    method test_cmd_nop_no_arg (line 33) | def test_cmd_nop_no_arg(self):
    method test_cmd_nop_check_b_and_n_same_time (line 44) | def test_cmd_nop_check_b_and_n_same_time(self):
    method test_cmd_nop_no_arg_break_instruction (line 51) | def test_cmd_nop_no_arg_break_instruction(self):
    method test_cmd_nop_force_arg_break_instruction (line 65) | def test_cmd_nop_force_arg_break_instruction(self):
    method test_cmd_nop_i_arg (line 78) | def test_cmd_nop_i_arg(self):
    method test_cmd_nop_i_arg_reaching_unmapped_area (line 88) | def test_cmd_nop_i_arg_reaching_unmapped_area(self):
    method test_cmd_nop_nop (line 102) | def test_cmd_nop_nop(self):
    method test_cmd_nop_nop_break_instruction (line 113) | def test_cmd_nop_nop_break_instruction(self):
    method test_cmd_nop_nop_break_instruction_force (line 124) | def test_cmd_nop_nop_break_instruction_force(self):
    method test_cmd_nop_nop_arg (line 135) | def test_cmd_nop_nop_arg(self):
    method test_cmd_nop_nop_arg_multibnop_breaks (line 145) | def test_cmd_nop_nop_arg_multibnop_breaks(self):
    method test_cmd_nop_nop_arg_multibnop_breaks_force (line 157) | def test_cmd_nop_nop_arg_multibnop_breaks_force(self):
    method test_cmd_nop_bytes (line 169) | def test_cmd_nop_bytes(self):
    method test_cmd_nop_bytes_break_instruction (line 183) | def test_cmd_nop_bytes_break_instruction(self):
    method test_cmd_nop_bytes_break_instruction_force (line 194) | def test_cmd_nop_bytes_break_instruction_force(self):
    method test_cmd_nop_bytes_arg (line 205) | def test_cmd_nop_bytes_arg(self):
    method test_cmd_nop_bytes_arg_nops_no_fit (line 216) | def test_cmd_nop_bytes_arg_nops_no_fit(self):
    method test_cmd_nop_bytes_arg_nops_no_fit_force (line 228) | def test_cmd_nop_bytes_arg_nops_no_fit_force(self):
  class NopCommandMmapKnownAddress (line 241) | class NopCommandMmapKnownAddress(RemoteGefUnitTestGeneric):
    method setUp (line 242) | def setUp(self) -> None:
    method test_cmd_nop_invalid_end_address (line 247) | def test_cmd_nop_invalid_end_address(self):
    method test_cmd_nop_as_bytes_invalid_end_address (line 254) | def test_cmd_nop_as_bytes_invalid_end_address(self):

FILE: tests/commands/patch.py
  class PatchCommand (line 10) | class PatchCommand(RemoteGefUnitTestGeneric):
    method test_cmd_patch (line 13) | def test_cmd_patch(self):
    method test_cmd_patch_byte (line 19) | def test_cmd_patch_byte(self):
    method test_cmd_patch_byte_bytearray (line 27) | def test_cmd_patch_byte_bytearray(self):
    method test_cmd_patch_word (line 36) | def test_cmd_patch_word(self):
    method test_cmd_patch_dword (line 44) | def test_cmd_patch_dword(self):
    method test_cmd_patch_qword (line 52) | def test_cmd_patch_qword(self):
    method test_cmd_patch_string (line 60) | def test_cmd_patch_string(self):
  class PatchCommandBss (line 68) | class PatchCommandBss(RemoteGefUnitTestGeneric):
    method setUp (line 69) | def setUp(self) -> None:
    method test_cmd_patch_qword_symbol (line 73) | def test_cmd_patch_qword_symbol(self):

FILE: tests/commands/pattern.py
  class PatternCommand (line 10) | class PatternCommand(RemoteGefUnitTestGeneric):
    method setUp (line 13) | def setUp(self) -> None:
    method test_cmd_pattern_create (line 17) | def test_cmd_pattern_create(self):
    method test_cmd_pattern_search (line 31) | def test_cmd_pattern_search(self):

FILE: tests/commands/pcustom.py
  class PcustomCommand (line 25) | class PcustomCommand(RemoteGefUnitTestGeneric):
    method setUp (line 28) | def setUp(self) -> None:
    method test_cmd_pcustom (line 32) | def test_cmd_pcustom(self):
    method test_cmd_pcustom_show (line 66) | def test_cmd_pcustom_show(self):

FILE: tests/commands/pie.py
  class PieCommand (line 9) | class PieCommand(RemoteGefUnitTestGeneric):
    method setUp (line 12) | def setUp(self) -> None:
    method test_cmd_pie (line 18) | def test_cmd_pie(self):
    method test_cmd_pie_breakpoint_check (line 26) | def test_cmd_pie_breakpoint_check(self):
    method test_cmd_pie_breakpoint_delete (line 36) | def test_cmd_pie_breakpoint_delete(self):
    method test_cmd_pie_breakpoint_run (line 43) | def test_cmd_pie_breakpoint_run(self):

FILE: tests/commands/print_format.py
  class PrintFormatCommand (line 10) | class PrintFormatCommand(RemoteGefUnitTestGeneric):
    method test_cmd_print_format (line 13) | def test_cmd_print_format(self):
    method test_cmd_print_format_bytearray (line 36) | def test_cmd_print_format_bytearray(self):

FILE: tests/commands/process_search.py
  class ProcessSearchCommand (line 10) | class ProcessSearchCommand(RemoteGefUnitTestGeneric):
    method setUp (line 13) | def setUp(self) -> None:
    method test_cmd_process_search1 (line 17) | def test_cmd_process_search1(self):
    method test_cmd_process_search_wildcart (line 24) | def test_cmd_process_search_wildcart(self):
    method test_cmd_process_search_smartscan (line 36) | def test_cmd_process_search_smartscan(self):

FILE: tests/commands/process_status.py
  class ProcessStatusCommand (line 10) | class ProcessStatusCommand(RemoteGefUnitTestGeneric):
    method test_cmd_process_status (line 13) | def test_cmd_process_status(self):

FILE: tests/commands/registers.py
  class RegistersCommand (line 12) | class RegistersCommand(RemoteGefUnitTestGeneric):
    method test_cmd_registers (line 19) | def test_cmd_registers(self):

FILE: tests/commands/reset_cache.py
  class ResetCacheCommand (line 9) | class ResetCacheCommand(RemoteGefUnitTestGeneric):
    method test_cmd_reset_cache (line 13) | def test_cmd_reset_cache(self):

FILE: tests/commands/scan.py
  class ScanCommand (line 11) | class ScanCommand(RemoteGefUnitTestGeneric):
    method setUp (line 14) | def setUp(self) -> None:
    method test_cmd_scan (line 19) | def test_cmd_scan(self):

FILE: tests/commands/search_pattern.py
  class SearchPatternCommand (line 10) | class SearchPatternCommand(RemoteGefUnitTestGeneric):
    method test_cmd_search_pattern (line 13) | def test_cmd_search_pattern(self):
    method test_cmd_search_pattern_regex (line 23) | def test_cmd_search_pattern_regex(self):

FILE: tests/commands/shellcode.py
  class ShellcodeCommand (line 10) | class ShellcodeCommand(RemoteGefUnitTestGeneric):
    method test_cmd_shellcode (line 13) | def test_cmd_shellcode(self):
    method test_cmd_shellcode_search (line 21) | def test_cmd_shellcode_search(self):
    method test_cmd_shellcode_get_ok (line 30) | def test_cmd_shellcode_get_ok(self):
    method test_cmd_shellcode_get_nok (line 38) | def test_cmd_shellcode_get_nok(self):

FILE: tests/commands/skipi.py
  class SkipiCommand (line 11) | class SkipiCommand(RemoteGefUnitTestGeneric):
    method test_cmd_nop_inactive (line 16) | def test_cmd_nop_inactive(self):
    method test_cmd_skipi_no_arg (line 22) | def test_cmd_skipi_no_arg(self):
    method test_cmd_skipi_skip_two_instructions (line 34) | def test_cmd_skipi_skip_two_instructions(self):
    method test_cmd_skipi_two_instructions_from_location (line 46) | def test_cmd_skipi_two_instructions_from_location(self):

FILE: tests/commands/smart_eval.py
  class SmartEvalCommand (line 9) | class SmartEvalCommand(RemoteGefUnitTestGeneric):
    method test_cmd_smart_eval (line 13) | def test_cmd_smart_eval(self):

FILE: tests/commands/stepover.py
  class Stepover (line 11) | class Stepover(RemoteGefUnitTestGeneric):
    method test_cmd_stepover_inactive (line 16) | def test_cmd_stepover_inactive(self):
    method test_cmd_stepover (line 22) | def test_cmd_stepover(self):

FILE: tests/commands/stub.py
  class StubCommand (line 11) | class StubCommand(RemoteGefUnitTestGeneric):
    method capfd (line 15) | def capfd(self, capfd):
    method test_cmd_stub (line 18) | def test_cmd_stub(self):

FILE: tests/commands/theme.py
  class ThemeCommand (line 9) | class ThemeCommand(RemoteGefUnitTestGeneric):
    method test_cmd_theme (line 12) | def test_cmd_theme(self):

FILE: tests/commands/trace_run.py
  class TraceRunCommand (line 10) | class TraceRunCommand(RemoteGefUnitTestGeneric):
    method test_cmd_trace_run (line 13) | def test_cmd_trace_run(self):

FILE: tests/commands/version.py
  class VersionCommand (line 9) | class VersionCommand(RemoteGefUnitTestGeneric):
    method test_cmd_version (line 14) | def test_cmd_version(self):

FILE: tests/commands/vmmap.py
  class VmmapCommand (line 10) | class VmmapCommand(RemoteGefUnitTestGeneric):
    method test_cmd_vmmap (line 13) | def test_cmd_vmmap(self):
    method test_cmd_vmmap_addr (line 30) | def test_cmd_vmmap_addr(self):
    method test_cmd_vmmap_name (line 42) | def test_cmd_vmmap_name(self):

FILE: tests/commands/xfiles.py
  class XfilesCommand (line 10) | class XfilesCommand(RemoteGefUnitTestGeneric):
    method test_cmd_xfiles (line 13) | def test_cmd_xfiles(self):

FILE: tests/commands/xinfo.py
  class XinfoCommand (line 10) | class XinfoCommand(RemoteGefUnitTestGeneric):
    method test_cmd_xinfo (line 13) | def test_cmd_xinfo(self):
  class XinfoCommandClass (line 27) | class XinfoCommandClass(RemoteGefUnitTestGeneric):
    method setUp (line 28) | def setUp(self) -> None:
    method test_cmd_xinfo_on_class (line 32) | def test_cmd_xinfo_on_class(self):

FILE: tests/commands/xor_memory.py
  class XorMemoryCommand (line 9) | class XorMemoryCommand(RemoteGefUnitTestGeneric):
    method test_cmd_xor_memory_display (line 13) | def test_cmd_xor_memory_display(self):
    method test_cmd_xor_memory_patch (line 24) | def test_cmd_xor_memory_patch(self):

FILE: tests/config/__init__.py
  class TestGefConfigUnit (line 13) | class TestGefConfigUnit(RemoteGefUnitTestGeneric):
    method test_config_show_opcodes_size (line 16) | def test_config_show_opcodes_size(self):
    method test_config_hook_validator (line 45) | def test_config_hook_validator(self):
    method test_config_type_validator (line 64) | def test_config_type_validator(self):
    method test_config_libc_version (line 81) | def test_config_libc_version(self):

FILE: tests/functions/elf_sections.py
  class ElfSectionGdbFunction (line 12) | class ElfSectionGdbFunction(RemoteGefUnitTestGeneric):
    method test_func_base (line 15) | def test_func_base(self):
    method test_func_stack (line 34) | def test_func_stack(self):
  class ElfSectionGdbFunctionBss (line 49) | class ElfSectionGdbFunctionBss(RemoteGefUnitTestGeneric):
    method setUp (line 50) | def setUp(self) -> None:
    method test_func_bss (line 54) | def test_func_bss(self):
  class ElfSectionGdbFunctionHeap (line 66) | class ElfSectionGdbFunctionHeap(RemoteGefUnitTestGeneric):
    method setUp (line 67) | def setUp(self) -> None:
    method test_func_got (line 71) | def test_func_got(self):
    method test_func_heap (line 83) | def test_func_heap(self):

FILE: tests/perf/benchmark.py
  class BenchmarkBasicApi (line 10) | class BenchmarkBasicApi(RemoteGefUnitTestGeneric):
    method benchmark (line 12) | def benchmark(self, benchmark):
    method test_cmd_context (line 16) | def test_cmd_context(self):
    method test_cmd_context_regs (line 22) | def test_cmd_context_regs(self):
    method test_cmd_context_stack (line 28) | def test_cmd_context_stack(self):
    method test_cmd_context_code (line 34) | def test_cmd_context_code(self):
    method test_gef_memory_maps (line 40) | def test_gef_memory_maps(self):
    method test_elf_parsing (line 51) | def test_elf_parsing(self):

FILE: tests/regressions/filename_collision_lookup.py
  class RegressionFilenameCollisionLookup (line 7) | class RegressionFilenameCollisionLookup(RemoteGefUnitTestGeneric):
    method setUp (line 14) | def setUp(self) -> None:
    method test_process_lookup_path_use_only_filename (line 18) | def test_process_lookup_path_use_only_filename(self):

FILE: tests/regressions/gdbserver_connection.py
  class RegressionGdbserverConnection (line 10) | class RegressionGdbserverConnection(RemoteGefUnitTestGeneric):
    method test_can_establish_connection_to_gdbserver_again_after_disconnect (line 12) | def test_can_establish_connection_to_gdbserver_again_after_disconnect(...

FILE: tests/regressions/registers_register_order.py
  class RegressionRegisterOrder (line 7) | class RegressionRegisterOrder(RemoteGefUnitTestGeneric):
    method test_registers_show_registers_in_correct_order (line 11) | def test_registers_show_registers_in_correct_order(self):
  class RegressionRegisterOrderNested (line 61) | class RegressionRegisterOrderNested(RemoteGefUnitTestGeneric):
    method setUp (line 62) | def setUp(self) -> None:
    method test_context_correct_registers_refresh_with_frames (line 70) | def test_context_correct_registers_refresh_with_frames(self):

FILE: tests/scripts/test_gef.py
  class GefInstallScript (line 14) | class GefInstallScript(unittest.TestCase):
    method setUp (line 15) | def setUp(self):
    method test_script_gef_sh (line 22) | def test_script_gef_sh(self):

FILE: tests/utils.py
  function which (line 20) | def which(program: str) -> pathlib.Path:
  class Color (line 60) | class Color(enum.Enum):
  function is_glibc_ge (line 81) | def is_glibc_ge(major, minor):
  function is_64b (line 89) | def is_64b() -> bool:
  function is_32b (line 93) | def is_32b() -> bool:
  function debug_target (line 97) | def debug_target(name: str, extension: str = ".out") -> pathlib.Path:
  function start_gdbserver (line 106) | def start_gdbserver(
  function stop_gdbserver (line 125) | def stop_gdbserver(gdbserver: subprocess.Popen) -> None:
  function gdbserver_session (line 138) | def gdbserver_session(
  function start_qemuuser (line 151) | def start_qemuuser(
  function stop_qemuuser (line 162) | def stop_qemuuser(process: subprocess.Popen) -> None:
  function qemuuser_session (line 169) | def qemuuser_session(*args, **kwargs):
  function find_symbol (line 179) | def find_symbol(binary: pathlib.Path, symbol: str) -> int:
  function findlines (line 209) | def findlines(substring: str, buffer: str) -> List[str]:
  function removeafter (line 223) | def removeafter(substring: str, buffer: str, included: bool = False) -> ...
  function removeuntil (line 245) | def removeuntil(substring: str, buffer: str, included: bool = False) -> ...
  function download_file (line 267) | def download_file(url: str) -> Optional[bytes]:
  function u8 (line 283) | def u8(x: bytes) -> int:
  function u16 (line 287) | def u16(x: bytes) -> int:
  function u32 (line 291) | def u32(x: bytes) -> int:
  function u64 (line 295) | def u64(x: bytes) -> int:
  function p8 (line 299) | def p8(x: int) -> bytes:
  function p16 (line 303) | def p16(x: int) -> bytes:
  function p32 (line 307) | def p32(x: int) -> bytes:
  function p64 (line 311) | def p64(x: int) -> bytes: