/* Generated by drgndoc.docstrings. */

const char drgn_DOC[] =
	"libdrgn bindings\n"
	"\n"
	"Don't use this module directly. Instead, use the drgn package.";
const char drgn_IntegerLike_DOC[] =
	"TypeAlias\n"
	"\n"
	"An :class:`int` or integer-like object.\n"
	"\n"
	"Parameters annotated with this type expect an integer which may be given as a\n"
	"Python :class:`int` or an :class:`Object` with integer type.\n"
	"\n"
	"This is equivalent to :class:`typing.SupportsIndex`.";
const char drgn_Path_DOC[] =
	"TypeAlias\n"
	"\n"
	"Filesystem path.\n"
	"\n"
	"Parameters annotated with this type accept a filesystem path as :class:`str`,\n"
	":class:`bytes`, or :class:`os.PathLike`.";
const char drgn_Program_DOC[] =
	"A ``Program`` represents a crashed or running program. It can be used to\n"
	"lookup type definitions, access variables, and read arbitrary memory.\n"
	"\n"
	"The main functionality of a ``Program`` is looking up objects (i.e.,\n"
	"variables, constants, or functions). This is usually done with the\n"
	":meth:`[] <.__getitem__>` operator.\n"
	"\n"
	"Program(platform: Optional[Platform] = None, *, vmcoreinfo: Union[bytes, str, None] = None)\n"
	"\n"
	"Create a ``Program`` with no target program. It is usually more\n"
	"convenient to use one of the :ref:`api-program-constructors`.\n"
	"\n"
	":param platform: The platform of the program, or ``None`` if it should\n"
	"    be determined automatically when a core dump or symbol file is\n"
	"    added.\n"
	":param vmcoreinfo: Optionally provide the ``VMCOREINFO`` note data for\n"
	"    Linux kernel core dumps, which will override any detected data. When\n"
	"    not provided or ``None``, automatically detect the info.";
const char drgn_Program___new___DOC[] =
	"__new__(platform: Optional[_drgn.Platform] = None, *, vmcoreinfo: Union[bytes, str, None] = None) -> Self\n"
	"\n"
	"Create a ``Program`` with no target program. It is usually more\n"
	"convenient to use one of the :ref:`api-program-constructors`.\n"
	"\n"
	":param platform: The platform of the program, or ``None`` if it should\n"
	"    be determined automatically when a core dump or symbol file is\n"
	"    added.\n"
	":param vmcoreinfo: Optionally provide the ``VMCOREINFO`` note data for\n"
	"    Linux kernel core dumps, which will override any detected data. When\n"
	"    not provided or ``None``, automatically detect the info.";
const char drgn_Program_flags_DOC[] =
	"_drgn.ProgramFlags\n"
	"\n"
	"Flags which apply to this program.";
const char drgn_Program_platform_DOC[] =
	"Optional[_drgn.Platform]\n"
	"\n"
	"Platform that this program runs on, or ``None`` if it has not been\n"
	"determined yet.";
const char drgn_Program_core_dump_path_DOC[] =
	"Optional[str]\n"
	"\n"
	"Path of the core dump that this program was created from, or ``None`` if it\n"
	"was not created from a core dump.";
const char drgn_Program_language_DOC[] =
	"_drgn.Language\n"
	"\n"
	"Default programming language of the program.\n"
	"\n"
	"This is used for interpreting the type name given to :meth:`type()` and\n"
	"when creating an :class:`Object` without an explicit type.\n"
	"\n"
	"For the Linux kernel, this defaults to :attr:`Language.C`. For userspace\n"
	"programs, this defaults to the language of ``main`` in the program, falling\n"
	"back to :attr:`Language.C`. This heuristic may change in the future.\n"
	"\n"
	"This can be explicitly set to a different language (e.g., if the heuristic\n"
	"was incorrect).";
const char drgn_Program___getitem___DOC[] =
	"__getitem__(name: str) -> _drgn.Object\n"
	"\n"
	"Implement ``self[name]``. Get the object (variable, constant, or\n"
	"function) with the given name.\n"
	"\n"
	"This is equivalent to ``prog.object(name)``.\n"
	"\n"
	"If there are multiple objects with the same name, one is returned\n"
	"arbitrarily. In this case, the :meth:`variable()`, :meth:`constant()`,\n"
	":meth:`function()`, or :meth:`object()` methods can be used instead.\n"
	"\n"
	">>> prog['jiffies']\n"
	"Object(prog, 'volatile unsigned long', address=0xffffffff94c05000)\n"
	"\n"
	":param name: Object name.";
const char drgn_Program___contains___DOC[] =
	"__contains__(name: str) -> bool\n"
	"\n"
	"Implement ``name in self``. Return whether an object (variable,\n"
	"constant, or function) with the given name exists in the program.\n"
	"\n"
	":param name: Object name.";
const char drgn_Program_variable_DOC[] =
	"variable(name: str, filename: Optional[str] = None) -> _drgn.Object\n"
	"\n"
	"Get the variable with the given name.\n"
	"\n"
	">>> prog.variable('jiffies')\n"
	"Object(prog, 'volatile unsigned long', address=0xffffffff94c05000)\n"
	"\n"
	"This is equivalent to ``prog.object(name, FindObjectFlags.VARIABLE,\n"
	"filename)``.\n"
	"\n"
	":param name: The variable name.\n"
	":param filename: The source code file that contains the definition. See\n"
	"    :ref:`api-filenames`.\n"
	":raises ObjectNotFoundError: if no variables with the given name are\n"
	"    found in the given file";
const char drgn_Program_constant_DOC[] =
	"constant(name: str, filename: Optional[str] = None) -> _drgn.Object\n"
	"\n"
	"Get the constant (e.g., enumeration constant) with the given name.\n"
	"\n"
	"Note that support for macro constants is not yet implemented for DWARF\n"
	"files, and most compilers don't generate macro debugging information by\n"
	"default anyways.\n"
	"\n"
	">>> prog.constant('PIDTYPE_MAX')\n"
	"Object(prog, 'enum pid_type', value=4)\n"
	"\n"
	"This is equivalent to ``prog.object(name, FindObjectFlags.CONSTANT,\n"
	"filename)``.\n"
	"\n"
	":param name: The constant name.\n"
	":param filename: The source code file that contains the definition. See\n"
	"    :ref:`api-filenames`.\n"
	":raises ObjectNotFoundError: if no constants with the given name are\n"
	"    found in the given file";
const char drgn_Program_function_DOC[] =
	"function(name: str, filename: Optional[str] = None) -> _drgn.Object\n"
	"\n"
	"Get the function with the given name.\n"
	"\n"
	">>> prog.function('schedule')\n"
	"Object(prog, 'void (void)', address=0xffffffff94392370)\n"
	"\n"
	"This is equivalent to ``prog.object(name, FindObjectFlags.FUNCTION,\n"
	"filename)``.\n"
	"\n"
	":param name: The function name.\n"
	":param filename: The source code file that contains the definition. See\n"
	"    :ref:`api-filenames`.\n"
	":raises ObjectNotFoundError: if no functions with the given name are\n"
	"    found in the given file";
const char drgn_Program_object_DOC[] =
	"object(name: str, flags: _drgn.FindObjectFlags = _drgn.FindObjectFlags.ANY, filename: Optional[str] = None) -> _drgn.Object\n"
	"\n"
	"Get the object (variable, constant, or function) with the given name.\n"
	"\n"
	"When debugging the Linux kernel, this can look up certain special\n"
	"objects documented in :ref:`kernel-special-objects`, sometimes without\n"
	"any debugging information loaded.\n"
	"\n"
	":param name: The object name.\n"
	":param flags: Flags indicating what kind of object to look for.\n"
	":param filename: The source code file that contains the definition. See\n"
	"    :ref:`api-filenames`.\n"
	":raises ObjectNotFoundError: if no objects with the given name are\n"
	"    found in the given file";
const char drgn_Program_symbol_DOC[] =
	"symbol(address_or_name: Union[_drgn.IntegerLike, str], /) -> _drgn.Symbol\n"
	"\n"
	"Get a symbol containing the given address, or a symbol with the given\n"
	"name.\n"
	"\n"
	"If there are multiple symbols containing a given address, then this\n"
	"will attempt to find the closest match.\n"
	"\n"
	"If searching by name or if there is a tie, global symbols are preferred\n"
	"over weak symbols, and weak symbols are preferred over other symbols.\n"
	"In other words: if a matching :attr:`SymbolBinding.GLOBAL` or\n"
	":attr:`SymbolBinding.UNIQUE` symbol is found, it is returned.\n"
	"Otherwise, if a matching :attr:`SymbolBinding.WEAK` symbol is found, it\n"
	"is returned. Otherwise, any matching symbol (e.g.,\n"
	":attr:`SymbolBinding.LOCAL`) is returned. If there is still a tie, one\n"
	"is returned arbitrarily. To retrieve all matching symbols, use\n"
	":meth:`symbols()`.\n"
	"\n"
	":param address_or_name: Address or name to search for.\n"
	":raises LookupError: if no symbol contains the given address or matches\n"
	"    the given name";
const char drgn_Program_symbols_DOC[] =
	"symbols(address_or_name: Union[None, _drgn.IntegerLike, str] = None, /) -> List[_drgn.Symbol]\n"
	"\n"
	"Get a list of global and local symbols, optionally matching a name or\n"
	"address.\n"
	"\n"
	"If a string argument is given, this returns all symbols matching that\n"
	"name. If an integer-like argument given, this returns a list of all\n"
	"symbols containing that address. If no argument is given, all symbols\n"
	"in the program are returned. In all cases, the symbols are returned in\n"
	"an unspecified order.\n"
	"\n"
	":param address_or_name: Address or name to search for.";
const char drgn_Program_stack_trace_DOC[] =
	"stack_trace(thread: Union[_drgn.Object, _drgn.IntegerLike]) -> _drgn.StackTrace\n"
	"\n"
	"Get the stack trace for the given thread in the program.\n"
	"\n"
	"``thread`` may be a thread ID (as defined by :manpage:`gettid(2)`), in\n"
	"which case this will unwind the stack for the thread with that ID. The\n"
	"ID may be a Python ``int`` or an integer :class:`Object`\n"
	"\n"
	"``thread`` may also be a ``struct pt_regs`` or ``struct pt_regs *``\n"
	"object, in which case the initial register values will be fetched from\n"
	"that object.\n"
	"\n"
	"Finally, if debugging the Linux kernel, ``thread`` may be a ``struct\n"
	"task_struct *`` object, in which case this will unwind the stack for\n"
	"that task. See :func:`drgn.helpers.linux.pid.find_task()`.\n"
	"\n"
	"This is implemented for the Linux kernel (both live and core dumps) as\n"
	"well as userspace core dumps; it is not yet implemented for live\n"
	"userspace processes.\n"
	"\n"
	":param thread: Thread ID, ``struct pt_regs`` object, or\n"
	"    ``struct task_struct *`` object.";
const char drgn_Program_stack_trace_from_pcs_DOC[] =
	"stack_trace_from_pcs(pcs: Sequence[_drgn.IntegerLike]) -> _drgn.StackTrace\n"
	"\n"
	"Get a stack trace with the supplied list of program counters.\n"
	"\n"
	":param pcs: List of program counters.";
const char drgn_Program_source_location_DOC[] =
	"source_location(address: Union[_drgn.IntegerLike, str], /) -> _drgn.SourceLocationList\n"
	"\n"
	"Find the source code location containing a code address.\n"
	"\n"
	"The address may be given as an integer or a string. A string argument\n"
	"must be a symbol name or hexadecimal address, optionally followed by a\n"
	"``+`` character and a decimal or hexadecimal offset. Hexadecimal\n"
	"numbers must be prefixed with \"0x\" or \"0X\". Whitespace between tokens\n"
	"is ignored.\n"
	"\n"
	">>> prog.source_location(\"__schedule\")\n"
	"__schedule at kernel/sched/core.c:6646:1\n"
	">>> prog.source_location(\"__schedule+0x2b6\")\n"
	"#0  context_switch at kernel/sched/core.c:5381:9\n"
	"#1  __schedule at kernel/sched/core.c:6765:8\n"
	">>> prog.source_location(0xffffffffb64d70a6)\n"
	"#0  context_switch at kernel/sched/core.c:5381:9\n"
	"#1  __schedule at kernel/sched/core.c:6765:8\n"
	"\n"
	"Because of function inlining, a code address may actually correspond to\n"
	"multiple source code locations. So, this returns a sequence of\n"
	"locations, where the first item corresponds to the innermost inlined\n"
	"function, the second item is its caller, etc.\n"
	"\n"
	".. note::\n"
	"\n"
	"    This is similar to :manpage:`addr2line(1)`.\n"
	"\n"
	":param address: Code address.\n"
	":raises LookupError: if the source code location is not found";
const char drgn_Program_type_DOC[] =
	"type(name: str, filename: Optional[str] = None) -> _drgn.Type\n"
	"\n"
	"Get the type with the given name.\n"
	"\n"
	">>> prog.type('long')\n"
	"prog.int_type(name='long', size=8, is_signed=True)\n"
	"\n"
	":param name: The type name.\n"
	":param filename: The source code file that contains the definition. See\n"
	"    :ref:`api-filenames`.\n"
	":raises LookupError: if no types with the given name are found in\n"
	"    the given file\n"
	"\n"
	"type(type: _drgn.Type, /) -> _drgn.Type\n"
	"\n"
	"Return the given type.\n"
	"\n"
	"This is mainly useful so that helpers can use ``prog.type()`` to get a\n"
	":class:`Type` regardless of whether they were given a :class:`str` or a\n"
	":class:`Type`. For example:\n"
	"\n"
	".. code-block:: python3\n"
	"\n"
	"    def my_helper(obj: Object, type: Union[str, Type]) -> bool:\n"
	"        # type may be str or Type.\n"
	"        type = obj.prog_.type(type)\n"
	"        # type is now always Type.\n"
	"        return sizeof(obj) > sizeof(type)\n"
	"\n"
	":param type: Type.\n"
	":return: The exact same type.";
const char drgn_Program_threads_DOC[] =
	"threads() -> Iterator[_drgn.Thread]\n"
	"\n"
	"Get an iterator over all of the threads in the program.";
const char drgn_Program_thread_DOC[] =
	"thread(tid: _drgn.IntegerLike) -> _drgn.Thread\n"
	"\n"
	"Get the thread with the given thread ID.\n"
	"\n"
	":param tid: Thread ID (as defined by :manpage:`gettid(2)`).\n"
	":raises LookupError: if no thread has the given thread ID";
const char drgn_Program_main_thread_DOC[] =
	"main_thread() -> _drgn.Thread\n"
	"\n"
	"Get the main thread of the program.\n"
	"\n"
	"This is only defined for userspace programs.\n"
	"\n"
	":raises ValueError: if the program is the Linux kernel";
const char drgn_Program_crashed_thread_DOC[] =
	"crashed_thread() -> _drgn.Thread\n"
	"\n"
	"Get the thread that caused the program to crash.\n"
	"\n"
	"For userspace programs, this is the thread that received the fatal\n"
	"signal (e.g., ``SIGSEGV`` or ``SIGQUIT``).\n"
	"\n"
	"For the kernel, this is the thread that panicked (either directly or as\n"
	"a result of an oops, ``BUG_ON()``, etc.).\n"
	"\n"
	":raises ValueError: if the program is live (i.e., not a core dump)";
const char drgn_Program_read_DOC[] =
	"read(address: _drgn.IntegerLike, size: _drgn.IntegerLike, physical: bool = False) -> bytes\n"
	"\n"
	"Read *size* bytes of memory starting at *address* in the program.\n"
	"\n"
	"The address may be virtual (the default) or physical if the program\n"
	"supports it.\n"
	"\n"
	">>> prog.read(0xffffffffbe012b40, 16)\n"
	"b'swapper/0\\x00\\x00\\x00\\x00\\x00\\x00\\x00'\n"
	"\n"
	":param address: Starting address.\n"
	":param size: Number of bytes to read.\n"
	":param physical: Whether *address* is a physical memory address. If\n"
	"    ``False``, then it is a virtual memory address. Physical memory can\n"
	"    usually only be read when the program is an operating system\n"
	"    kernel.\n"
	":raises FaultError: if the address range is invalid or the type of\n"
	"    address (physical or virtual) is not supported by the program\n"
	":raises ValueError: if *size* is negative";
const char drgn_Program_read_c_string_DOC[] =
	"read_c_string(address: _drgn.IntegerLike, physical: bool = False, *, max_size: _drgn.IntegerLike = ...) -> bytes\n"
	"\n"
	"Read a null-terminated string starting at *address* in the program.\n"
	"\n"
	">>> prog.read_c_string(0xffffffffbe012b40)\n"
	"b'swapper/0'\n"
	">>> prog.read_c_string(0xffffffffbe012b40, max_size=4)\n"
	"b'swap'\n"
	">>> prog.read_c_string(0xffffffffbe012b40, max_size=10)\n"
	"b'swapper/0'\n"
	"\n"
	":param address: Starting address.\n"
	":param physical: Whether *address* is a physical memory address; see\n"
	"    :meth:`read()`.\n"
	":param max_size: Stop after this many bytes are read, not including the\n"
	"    null byte. The default is no limit.\n"
	":raises FaultError: if an invalid address is accessed before finding a\n"
	"    null terminator, or if the type of address (physical or virtual) is\n"
	"    not supported by the program\n"
	":raises ValueError: if *max_size* is negative";
const char drgn_Program_read_u8_DOC[] =
	"read_u8(address: _drgn.IntegerLike, physical: bool = False) -> int";
const char drgn_Program_read_u16_DOC[] =
	"read_u16(address: _drgn.IntegerLike, physical: bool = False) -> int";
const char drgn_Program_read_u32_DOC[] =
	"read_u32(address: _drgn.IntegerLike, physical: bool = False) -> int";
const char drgn_Program_read_u64_DOC[] =
	"read_u64(address: _drgn.IntegerLike, physical: bool = False) -> int";
const char drgn_Program_read_word_DOC[] =
	"read_word(address: _drgn.IntegerLike, physical: bool = False) -> int\n"
	"\n"
	"Read an unsigned integer from the program's memory in the program's\n"
	"byte order.\n"
	"\n"
	":meth:`read_u8()`, :meth:`read_u16()`, :meth:`read_u32()`, and\n"
	":meth:`read_u64()` read an 8-, 16-, 32-, or 64-bit unsigned integer,\n"
	"respectively. :meth:`read_word()` reads a program word-sized unsigned\n"
	"integer.\n"
	"\n"
	"For signed integers, alternate byte order, or other formats, you can\n"
	"use :meth:`read()` and :meth:`int.from_bytes()` or the :mod:`struct`\n"
	"module.\n"
	"\n"
	":param address: Address of the integer.\n"
	":param physical: Whether *address* is a physical memory address; see\n"
	"    :meth:`read()`.\n"
	":raises FaultError: if the address is invalid; see :meth:`read()`";
const char drgn_Program_search_memory_DOC[] =
	"search_memory(value: Union[bytes, str], *, alignment: int = 1) -> _drgn.MemorySearchIterator[int]\n"
	"\n"
	"search_memory(value: Union[_drgn.IntegerLike, _drgn.Object]) -> _drgn.MemorySearchIterator[int]";
const char drgn_Program_search_memory_u16_DOC[] =
	"search_memory_u16(*values: Union[_drgn.IntegerLike, Tuple[_drgn.IntegerLike, _drgn.IntegerLike]], ignore_mask: _drgn.IntegerLike = 0) -> _drgn.MemorySearchIterator[Tuple[int, int]]";
const char drgn_Program_search_memory_u32_DOC[] =
	"search_memory_u32(*values: Union[_drgn.IntegerLike, Tuple[_drgn.IntegerLike, _drgn.IntegerLike]], ignore_mask: _drgn.IntegerLike = 0) -> _drgn.MemorySearchIterator[Tuple[int, int]]";
const char drgn_Program_search_memory_u64_DOC[] =
	"search_memory_u64(*values: Union[_drgn.IntegerLike, Tuple[_drgn.IntegerLike, _drgn.IntegerLike]], ignore_mask: _drgn.IntegerLike = 0) -> _drgn.MemorySearchIterator[Tuple[int, int]]";
const char drgn_Program_search_memory_word_DOC[] =
	"search_memory_word(*values: Union[_drgn.IntegerLike, Tuple[_drgn.IntegerLike, _drgn.IntegerLike]], ignore_mask: _drgn.IntegerLike = 0) -> _drgn.MemorySearchIterator[Tuple[int, int]]";
const char drgn_Program_search_memory_regex_DOC[] =
	"search_memory_regex(pattern: bytes) -> _drgn.MemorySearchIterator[Tuple[int, bytes]]\n"
	"\n"
	"search_memory_regex(pattern: str) -> _drgn.MemorySearchIterator[Tuple[int, str]]\n"
	"\n"
	"See :ref:`api-searching-memory`.";
const char drgn_Program_add_memory_segment_DOC[] =
	"add_memory_segment(address: _drgn.IntegerLike, size: _drgn.IntegerLike, read_fn: Callable[[int, int, int, bool], bytes], physical: bool = False) -> None\n"
	"\n"
	"Define a region of memory in the program.\n"
	"\n"
	"If it overlaps a previously registered segment, the new segment takes\n"
	"precedence.\n"
	"\n"
	":param address: Address of the segment.\n"
	":param size: Size of the segment in bytes.\n"
	":param physical: Whether to add a physical memory segment. If\n"
	"    ``False``, then this adds a virtual memory segment.\n"
	":param read_fn: Callable to call to read memory from the segment. It is\n"
	"    passed the address being read from, the number of bytes to read,\n"
	"    the offset in bytes from the beginning of the segment, and whether\n"
	"    the address is physical: ``(address, count, offset, physical)``. It\n"
	"    should return the requested number of bytes as :class:`bytes` or\n"
	"    another :ref:`buffer <python:binaryseq>` type.";
const char drgn_Program_register_type_finder_DOC[] =
	"register_type_finder(name: str, fn: Callable[[_drgn.Program, _drgn.TypeKindSet, str, Optional[str]], Optional[_drgn.Type]], *, enable_index: Optional[int] = None) -> None\n"
	"\n"
	"Register a callback for finding types in the program.\n"
	"\n"
	"This does not enable the finder unless *enable_index* is given.\n"
	"\n"
	":param name: Finder name.\n"
	":param fn: Callable taking the program, a :class:`TypeKindSet`, name,\n"
	"    and filename: ``(prog, kinds, name, filename)``. The filename\n"
	"    should be matched with :func:`filename_matches()`. This should\n"
	"    return a :class:`Type` or ``None`` if not found.\n"
	":param enable_index: Insert the finder into the list of enabled type\n"
	"    finders at the given index. If -1 or greater than the number of\n"
	"    enabled finders, insert it at the end. If ``None`` or not given,\n"
	"    don't enable the finder.\n"
	":raises ValueError: if there is already a finder with the given name";
const char drgn_Program_registered_type_finders_DOC[] =
	"registered_type_finders() -> Set[str]\n"
	"\n"
	"Return the names of all registered type finders.";
const char drgn_Program_set_enabled_type_finders_DOC[] =
	"set_enabled_type_finders(names: Sequence[str]) -> None\n"
	"\n"
	"Set the list of enabled type finders.\n"
	"\n"
	"Finders are called in the same order as the list until a type is found.\n"
	"\n"
	"Finders that are not in the list are not called.\n"
	"\n"
	":param names: Names of finders to enable, in order.\n"
	":raises ValueError: if no finder has a given name or the same name is\n"
	"    given more than once";
const char drgn_Program_enabled_type_finders_DOC[] =
	"enabled_type_finders() -> List[str]\n"
	"\n"
	"Return the names of enabled type finders, in order.";
const char drgn_Program_register_object_finder_DOC[] =
	"register_object_finder(name: str, fn: Callable[[_drgn.Program, str, _drgn.FindObjectFlags, Optional[str]], Optional[_drgn.Object]], *, enable_index: Optional[int] = None) -> None\n"
	"\n"
	"Register a callback for finding objects in the program.\n"
	"\n"
	"This does not enable the finder unless *enable_index* is given.\n"
	"\n"
	":param name: Finder name.\n"
	":param fn: Callable taking the program, name, :class:`FindObjectFlags`,\n"
	"    and filename: ``(prog, name, flags, filename)``. The filename\n"
	"    should be matched with :func:`filename_matches()`. This should\n"
	"    return an :class:`Object` or ``None`` if not found.\n"
	":param enable_index: Insert the finder into the list of enabled object\n"
	"    finders at the given index. If -1 or greater than the number of\n"
	"    enabled finders, insert it at the end. If ``None`` or not given,\n"
	"    don't enable the finder.\n"
	":raises ValueError: if there is already a finder with the given name";
const char drgn_Program_registered_object_finders_DOC[] =
	"registered_object_finders() -> Set[str]\n"
	"\n"
	"Return the names of all registered object finders.";
const char drgn_Program_set_enabled_object_finders_DOC[] =
	"set_enabled_object_finders(names: Sequence[str]) -> None\n"
	"\n"
	"Set the list of enabled object finders.\n"
	"\n"
	"Finders are called in the same order as the list until an object is found.\n"
	"\n"
	"Finders that are not in the list are not called.\n"
	"\n"
	":param names: Names of finders to enable, in order.\n"
	":raises ValueError: if no finder has a given name or the same name is\n"
	"    given more than once";
const char drgn_Program_enabled_object_finders_DOC[] =
	"enabled_object_finders() -> List[str]\n"
	"\n"
	"Return the names of enabled object finders, in order.";
const char drgn_Program_register_symbol_finder_DOC[] =
	"register_symbol_finder(name: str, fn: Callable[[_drgn.Program, Optional[str], Optional[int], bool], Sequence[_drgn.Symbol]], *, enable_index: Optional[int] = None) -> None\n"
	"\n"
	"Register a callback for finding symbols in the program.\n"
	"\n"
	"This does not enable the finder unless *enable_index* is given.\n"
	"\n"
	"The callback should take four arguments: the program, a *name*, an\n"
	"*address*, and a boolean flag *one*. It should return a list of symbols\n"
	"or an empty list if no matches are found.\n"
	"\n"
	"If *name* is not ``None``, then only symbols with that name should be\n"
	"returned. If *address* is not ``None``, then only symbols containing\n"
	"that address should be returned. If neither is ``None``, then the\n"
	"returned symbols must match both. If both are ``None``, then all\n"
	"symbols should be considered matching.\n"
	"\n"
	"When the *one* flag is ``False``, the callback should return a list of\n"
	"all matching symbols. When it is ``True``, it should return a list with\n"
	"at most one symbol which is the best match.\n"
	"\n"
	":param name: Finder name.\n"
	":param fn: Callable taking ``(prog, name, address, one)`` and returning\n"
	"    a sequence of :class:`Symbol`\\ s.\n"
	":param enable_index: Insert the finder into the list of enabled finders\n"
	"    at the given index. If -1 or greater than the number of enabled\n"
	"    finders, insert it at the end. If ``None`` or not given, don't\n"
	"    enable the finder.\n"
	":raises ValueError: if there is already a finder with the given name";
const char drgn_Program_registered_symbol_finders_DOC[] =
	"registered_symbol_finders() -> Set[str]\n"
	"\n"
	"Return the names of all registered symbol finders.";
const char drgn_Program_set_enabled_symbol_finders_DOC[] =
	"set_enabled_symbol_finders(names: Sequence[str]) -> None\n"
	"\n"
	"Set the list of enabled symbol finders.\n"
	"\n"
	"Finders are called in the same order as the list. When the *one* flag\n"
	"is set, the search will short-circuit after the first finder which\n"
	"returns a result, and subsequent finders will not be called. Otherwise,\n"
	"all callbacks will be called, and all results will be returned.\n"
	"\n"
	"Finders that are not in the list are not called.\n"
	"\n"
	":param names: Names of finders to enable, in order.\n"
	":raises ValueError: if no finder has a given name or the same name is\n"
	"    given more than once";
const char drgn_Program_enabled_symbol_finders_DOC[] =
	"enabled_symbol_finders() -> List[str]\n"
	"\n"
	"Return the names of enabled symbol finders, in order.";
const char drgn_Program_add_type_finder_DOC[] =
	"add_type_finder(fn: Callable[[_drgn.TypeKind, str, Optional[str]], Optional[_drgn.Type]]) -> None\n"
	"\n"
	"Deprecated method to register and enable a callback for finding types\n"
	"in the program.\n"
	"\n"
	".. deprecated:: 0.0.27\n"
	"    Use :meth:`register_type_finder()` instead.\n"
	"\n"
	"The differences from :meth:`register_type_finder()` are:\n"
	"\n"
	"1. *fn* is not passed *prog*.\n"
	"2. *fn* is passed a :class:`TypeKind` instead of a\n"
	"   :class:`TypeKindSet`. If multiple kinds are being searched for, *fn*\n"
	"   will be called multiple times.\n"
	"3. A name for the finder is generated from *fn*.\n"
	"4. The finder is always enabled before any existing finders.";
const char drgn_Program_add_object_finder_DOC[] =
	"add_object_finder(fn: Callable[[_drgn.Program, str, _drgn.FindObjectFlags, Optional[str]], Optional[_drgn.Object]]) -> None\n"
	"\n"
	"Deprecated method to register and enable a callback for finding objects\n"
	"in the program.\n"
	"\n"
	".. deprecated:: 0.0.27\n"
	"    Use :meth:`register_object_finder()` instead.\n"
	"\n"
	"The differences from :meth:`register_object_finder()` are:\n"
	"\n"
	"1. A name for the finder is generated from *fn*.\n"
	"2. The finder is always enabled before any existing finders.";
const char drgn_Program_set_core_dump_DOC[] =
	"set_core_dump(path: Union[_drgn.Path, int]) -> None\n"
	"\n"
	"Set the program to a core dump.\n"
	"\n"
	"This loads the memory segments from the core dump and determines the\n"
	"mapped executable and libraries. It does not load any debugging\n"
	"symbols; see :meth:`load_default_debug_info()`.\n"
	"\n"
	":param path: Core dump file path or open file descriptor.";
const char drgn_Program_set_kernel_DOC[] =
	"set_kernel() -> None\n"
	"\n"
	"Set the program to the running operating system kernel.\n"
	"\n"
	"This loads the memory of the running kernel and thus requires root\n"
	"privileges. It does not load any debugging symbols; see\n"
	":meth:`load_default_debug_info()`.";
const char drgn_Program_set_linux_kernel_custom_DOC[] =
	"set_linux_kernel_custom(vmcoreinfo: Union[str, bytes], is_live: bool) -> None\n"
	"\n"
	"Set the program to a custom Linux kernel target.\n"
	"\n"
	"This enables debugging a Linux kernel via a custom memory transport\n"
	"(e.g., RDMA, TCP/IP, or VMM introspection). It sets up page table\n"
	"walking for virtual address translation. It does not load any\n"
	"debugging symbols; see :meth:`load_default_debug_info()`.\n"
	"\n"
	"Physical memory segments must be registered via\n"
	":meth:`add_memory_segment()` with ``physical=True`` before reading\n"
	"memory. Platform must be provided when creating the :class:`Program`.\n"
	"\n"
	":param vmcoreinfo: Raw vmcoreinfo data. If vmcoreinfo was already set\n"
	"    when creating the :class:`Program`, this is ignored.\n"
	":param is_live: Whether the kernel is currently running.";
const char drgn_Program_set_pid_DOC[] =
	"set_pid(pid: int) -> None\n"
	"\n"
	"Set the program to a running process.\n"
	"\n"
	"This loads the memory of the process and determines the mapped\n"
	"executable and libraries. It does not load any debugging symbols; see\n"
	":meth:`load_default_debug_info()`.\n"
	"\n"
	":param pid: Process ID.";
const char drgn_Program_set_qemu_qmp_DOC[] =
	"set_qemu_qmp(address: Union[str, int]) -> None\n"
	"\n"
	"Set the program to a QEMU guest over the QEMU Machine Protocol (QMP).\n"
	"\n"
	"This does not load any debugging symbols; see\n"
	":meth:`load_default_debug_info()`.\n"
	"\n"
	".. note::\n"
	"\n"
	"    This can identify Linux kernel guests automatically. To do so, you\n"
	"    must:\n"
	"\n"
	"    1. Use a Unix domain socket for the QMP connection (e.g., run QEMU\n"
	"       with ``-qmp unix:/path/to/sock,server=on,wait=off``).\n"
	"    2. Use a Linux kernel version >= 4.17 in the guest.\n"
	"    3. Run QEMU with ``-device vmcoreinfo``.\n"
	"    4. Set ``CONFIG_KEXEC=y`` and ``CONFIG_FW_CFG_SYSFS=y`` in the\n"
	"       guest kernel's configuration. (Alternatively, you can use\n"
	"       ``CONFIG_FW_CFG_SYSFS=m`` and ensure that the ``qemu_fw_cfg``\n"
	"       kernel module is loaded.)\n"
	"\n"
	"    Otherwise, you may need to pass *vmcoreinfo* explicitly to\n"
	"    :class:`Program()`.\n"
	"\n"
	":param address: QMP socket address or file descriptor. If the address\n"
	"    is in the format ``host:port``, where ``host`` is a hostname, IP\n"
	"    address, or empty (for localhost) and ``port`` is a valid port\n"
	"    number (decimal integer 1-65535), then it is interpreted as a TCP\n"
	"    address. Otherwise, it is interpreted as a Unix domain socket path.\n"
	"\n"
	"    Note that hostnames may not begin with ``/`` or ``.``, so a Unix\n"
	"    domain socket path containing ``:`` may be prefixed with one of\n"
	"    those to disambiguate it.";
const char drgn_Program_modules_DOC[] =
	"modules() -> Iterator[_drgn.Module]\n"
	"\n"
	"Get an iterator over all of the created modules in the program.";
const char drgn_Program_loaded_modules_DOC[] =
	"loaded_modules() -> Iterator[Tuple[_drgn.Module, bool]]\n"
	"\n"
	"Get an iterator over executables, libraries, etc. that are loaded in\n"
	"the program, creating modules to represent them.\n"
	"\n"
	"Modules are created lazily as items are consumed.\n"
	"\n"
	"This may automatically load some debugging information necessary to\n"
	"enumerate the modules. Other than that, it does not load debugging\n"
	"information.\n"
	"\n"
	"See :meth:`load_debug_info()` for a higher-level interface that does\n"
	"load debugging information.\n"
	"\n"
	":return: Iterator of module and ``True`` if it was newly created\n"
	"    or ``False`` if it was previously found.";
const char drgn_Program_create_loaded_modules_DOC[] =
	"create_loaded_modules() -> None\n"
	"\n"
	"Determine what executables, libraries, etc. are loaded in the program\n"
	"and create modules to represent them.\n"
	"\n"
	"This is a shortcut for exhausting a :meth:`loaded_modules()` iterator.\n"
	"It is equivalent to:\n"
	"\n"
	".. code-block:: python3\n"
	"\n"
	"    for _ in prog.loaded_modules():\n"
	"        pass";
const char drgn_Program_main_module_DOC[] =
	"main_module() -> _drgn.MainModule\n"
	"\n"
	"Find the main module.\n"
	"\n"
	":raises LookupError: if the main module has not been created\n"
	"\n"
	"main_module(name: _drgn.Path, *, create: bool = False) -> _drgn.MainModule\n"
	"\n"
	"Find the main module.\n"
	"\n"
	":param name: :attr:`Module.name`\n"
	":param create: Create the module if it doesn't exist.\n"
	":raises LookupError: if the main module has not been created and\n"
	"    *create* is ``False``, or if the main module has already been\n"
	"    created with a different name";
const char drgn_Program_shared_library_module_DOC[] =
	"shared_library_module(name: _drgn.Path, dynamic_address: _drgn.IntegerLike, *, create: bool = False) -> _drgn.SharedLibraryModule\n"
	"\n"
	"Find a shared library module.\n"
	"\n"
	":param name: :attr:`Module.name`\n"
	":param dynamic_address: :attr:`SharedLibraryModule.dynamic_address`\n"
	":param create: Create the module if it doesn't exist.\n"
	":return: Shared library module with the given name and dynamic address.\n"
	":raises LookupError: if no matching module has been created and\n"
	"    *create* is ``False``";
const char drgn_Program_vdso_module_DOC[] =
	"vdso_module(name: _drgn.Path, dynamic_address: _drgn.IntegerLike, *, create: bool = False) -> _drgn.VdsoModule\n"
	"\n"
	"Find a vDSO module.\n"
	"\n"
	":param name: :attr:`Module.name`\n"
	":param dynamic_address: :attr:`VdsoModule.dynamic_address`\n"
	":param create: Create the module if it doesn't exist.\n"
	":return: vDSO module with the given name and dynamic address.\n"
	":raises LookupError: if no matching module has been created and\n"
	"    *create* is ``False``";
const char drgn_Program_relocatable_module_DOC[] =
	"relocatable_module(name: _drgn.Path, address: _drgn.IntegerLike, *, create: bool = False) -> _drgn.RelocatableModule\n"
	"\n"
	"Find a relocatable module.\n"
	"\n"
	":param name: :attr:`Module.name`\n"
	":param address: :attr:`RelocatableModule.address`\n"
	":param create: Create the module if it doesn't exist.\n"
	":return: Relocatable module with the given name and address.\n"
	":raises LookupError: if no matching module has been created and\n"
	"    *create* is ``False``";
const char drgn_Program_linux_kernel_loadable_module_DOC[] =
	"linux_kernel_loadable_module(module_obj: _drgn.Object, *, create: bool = False) -> _drgn.RelocatableModule\n"
	"\n"
	"Find a Linux kernel loadable module from a ``struct module *`` object.\n"
	"\n"
	"Note that kernel modules are represented as relocatable modules.\n"
	"\n"
	":param module_obj: ``struct module *`` object for the kernel module.\n"
	":param create: Create the module if it doesn't exist.\n"
	":return: Relocatable module with a name and address matching\n"
	"    *module_obj*.\n"
	":raises LookupError: if no matching module has been created and\n"
	"    *create* is ``False``";
const char drgn_Program_extra_module_DOC[] =
	"extra_module(name: _drgn.Path, id: _drgn.IntegerLike = 0, *, create: bool = False) -> _drgn.ExtraModule\n"
	"\n"
	"Find an extra module.\n"
	"\n"
	":param name: :attr:`Module.name`\n"
	":param id: :attr:`ExtraModule.id`\n"
	":param create: Create the module if it doesn't exist.\n"
	":return: Extra module with the given name and ID number.\n"
	":raises LookupError: if no matching module has been created and\n"
	"    *create* is ``False``";
const char drgn_Program_module_DOC[] =
	"module(address_or_name: Union[_drgn.IntegerLike, str], /) -> _drgn.Module\n"
	"\n"
	"Find the module containing the given address, or the module with the\n"
	"given name.\n"
	"\n"
	"Addresses are matched based on :attr:`Module.address_ranges`.\n"
	"\n"
	"If there are multiple modules with the given name, one is returned\n"
	"arbitrarily.\n"
	"\n"
	":param address_or_name: Address or name to search for.\n"
	":raises LookupError: if no module contains the given address or has the\n"
	"    given name";
const char drgn_Program_register_debug_info_finder_DOC[] =
	"register_debug_info_finder(name: str, fn: Callable[[Sequence[_drgn.Module]], None], *, enable_index: Optional[int] = None) -> None\n"
	"\n"
	"Register a callback for finding debugging information.\n"
	"\n"
	"This does not enable the finder unless *enable_index* is given.\n"
	"\n"
	":param name: Finder name.\n"
	":param fn: Callable taking a list of :class:`Module`\\ s that want\n"
	"    debugging information.\n"
	"\n"
	"    This should check :meth:`Module.wants_loaded_file()` and\n"
	"    :meth:`Module.wants_debug_file()` and do one of the following for\n"
	"    each module:\n"
	"\n"
	"    * Obtain and/or locate a file wanted by the module and call\n"
	"      :meth:`Module.try_file()`.\n"
	"    * Install files for a later finder to use.\n"
	"    * Set :attr:`Module.loaded_file_status` or\n"
	"      :attr:`Module.debug_file_status` to\n"
	"      :attr:`ModuleFileStatus.DONT_NEED` if the finder believes that\n"
	"      the file is not needed.\n"
	"    * Ignore it, for example if the finder doesn't know how to find the\n"
	"      wanted files for the module.\n"
	":param enable_index: Insert the finder into the list of enabled object\n"
	"    finders at the given index. If -1 or greater than the number of\n"
	"    enabled finders, insert it at the end. If ``None`` or not given,\n"
	"    don't enable the finder.\n"
	":raises ValueError: if there is already a finder with the given name";
const char drgn_Program_registered_debug_info_finders_DOC[] =
	"registered_debug_info_finders() -> Set[str]\n"
	"\n"
	"Return the names of all registered debugging information finders.";
const char drgn_Program_set_enabled_debug_info_finders_DOC[] =
	"set_enabled_debug_info_finders(names: Sequence[str]) -> None\n"
	"\n"
	"Set the list of enabled debugging information finders.\n"
	"\n"
	"Finders are called in the same order as the list until all wanted files\n"
	"have been found.\n"
	"\n"
	"Finders that are not in the list are not called.\n"
	"\n"
	":param names: Names of finders to enable, in order.\n"
	":raises ValueError: if no finder has a given name or the same name is\n"
	"    given more than once";
const char drgn_Program_enabled_debug_info_finders_DOC[] =
	"enabled_debug_info_finders() -> List[str]\n"
	"\n"
	"Return the names of enabled debugging information finders, in order.";
const char drgn_Program_debug_info_options_DOC[] =
	"_drgn.DebugInfoOptions\n"
	"\n"
	"Default options for debugging information searches.";
const char drgn_Program_load_debug_info_DOC[] =
	"load_debug_info(paths: Optional[Iterable[_drgn.Path]] = (), default: bool = False, main: bool = False) -> None\n"
	"\n"
	"Load debugging information for the given set of files and/or modules.\n"
	"\n"
	"This determines what executables, libraries, etc. are loaded in the\n"
	"program (see :meth:`loaded_modules()`) and tries to load their\n"
	"debugging information from the given *paths*.\n"
	"\n"
	".. note::\n"
	"    It is much more efficient to load multiple files at once rather\n"
	"    than one by one when possible.\n"
	"\n"
	":param paths: Paths of binary files to try.\n"
	"\n"
	"    Files that don't correspond to any loaded modules are ignored. See\n"
	"    :class:`ExtraModule` for a way to provide arbitrary debugging\n"
	"    information.\n"
	":param default: Try to load all debugging information for all loaded\n"
	"    modules.\n"
	"\n"
	"    The files in *paths* are tried first before falling back to the\n"
	"    enabled debugging information finders.\n"
	"\n"
	"    This implies ``main=True``.\n"
	":param main: Try to load all debugging information for the main module.\n"
	"\n"
	"    The files in *paths* are tried first before falling back to the\n"
	"    enabled debugging information finders.\n"
	":raises MissingDebugInfoError: if debugging information was not\n"
	"    available for some files; other files with debugging information\n"
	"    are still loaded";
const char drgn_Program_load_default_debug_info_DOC[] =
	"load_default_debug_info() -> None\n"
	"\n"
	"Load all debugging information that can automatically be determined\n"
	"from the program.\n"
	"\n"
	"This is equivalent to ``load_debug_info(default=True)``.";
const char drgn_Program_load_module_debug_info_DOC[] =
	"load_module_debug_info(*modules: _drgn.Module) -> None\n"
	"\n"
	"Load debugging information for the given modules using the enabled\n"
	"debugging information finders.\n"
	"\n"
	"The files to search for are controlled by\n"
	":attr:`Module.loaded_file_status` and :attr:`Module.debug_file_status`.";
const char drgn_Program_find_standard_debug_info_DOC[] =
	"find_standard_debug_info(modules: Iterable[_drgn.Module], options: Optional[_drgn.DebugInfoOptions] = None) -> None\n"
	"\n"
	"Load debugging information for the given modules from the standard\n"
	"locations.\n"
	"\n"
	"This is equivalent to the ``standard`` debugging information finder\n"
	"that is registered by default. It is intended for use by other\n"
	"debugging information finders that need a variation of the standard\n"
	"finder (e.g., after installing something or setting specific options).\n"
	"\n"
	":param modules: Modules to load debugging information for.\n"
	":param options: Options to use when searching for debugging\n"
	"    information. If ``None`` or not given, this uses\n"
	"    :attr:`self.debug_info_options <debug_info_options>`.";
const char drgn_Program_address_size_DOC[] =
	"address_size() -> int\n"
	"\n"
	"Get the size of an address in this program, in bytes.\n"
	"\n"
	":raises ValueError: if the size of an address is not known because\n"
	"    :attr:`platform` has not been determined yet";
const char drgn_Program_cache_DOC[] =
	"Dict[Any, Any]\n"
	"\n"
	"Dictionary for caching program metadata.\n"
	"\n"
	"This isn't used by the :class:`Program` itself. It is intended to be used\n"
	"by helpers to cache metadata about the program. For example, if a helper\n"
	"for a program depends on the program version or an optional feature, the\n"
	"helper can detect it and cache it for subsequent invocations:\n"
	"\n"
	".. code-block:: python3\n"
	"\n"
	"    def my_helper(prog):\n"
	"        try:\n"
	"            have_foo = prog.cache[\"have_foo\"]\n"
	"        except KeyError:\n"
	"            have_foo = detect_foo_feature(prog)\n"
	"            prog.cache[\"have_foo\"] = have_foo\n"
	"        if have_foo:\n"
	"            return prog[\"foo\"]\n"
	"        else:\n"
	"            return prog[\"bar\"]";
const char drgn_Program_config_DOC[] =
	"Dict[str, Any]\n"
	"\n"
	"Dictionary for configuration options.\n"
	"\n"
	"This isn't used by the :class:`Program` itself. It can be used to store\n"
	"configuration options for commands and helpers.";
const char drgn_Program_void_type_DOC[] =
	"void_type(*, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new void type. It has kind :attr:`TypeKind.VOID`.\n"
	"\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_Program_int_type_DOC[] =
	"int_type(name: str, size: _drgn.IntegerLike, is_signed: bool, byteorder: Optional[str] = None, *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new integer type. It has kind :attr:`TypeKind.INT`.\n"
	"\n"
	":param name: :attr:`Type.name`\n"
	":param size: :attr:`Type.size`\n"
	":param is_signed: :attr:`Type.is_signed`\n"
	":param byteorder: :attr:`Type.byteorder`, or ``None`` to use the\n"
	"    program's default byte order.\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_Program_bool_type_DOC[] =
	"bool_type(name: str, size: _drgn.IntegerLike, byteorder: Optional[str] = None, *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new boolean type. It has kind :attr:`TypeKind.BOOL`.\n"
	"\n"
	":param name: :attr:`Type.name`\n"
	":param size: :attr:`Type.size`\n"
	":param byteorder: :attr:`Type.byteorder`, or ``None`` to use the\n"
	"    program's default byte order.\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_Program_float_type_DOC[] =
	"float_type(name: str, size: _drgn.IntegerLike, byteorder: Optional[str] = None, *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new floating-point type. It has kind :attr:`TypeKind.FLOAT`.\n"
	"\n"
	":param name: :attr:`Type.name`\n"
	":param size: :attr:`Type.size`\n"
	":param byteorder: :attr:`Type.byteorder`, or ``None`` to use the\n"
	"    program's default byte order.\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_Program_struct_type_DOC[] =
	"struct_type(tag: Optional[str], size: _drgn.IntegerLike, members: Sequence[_drgn.TypeMember], *, template_parameters: Sequence[_drgn.TypeTemplateParameter] = (), qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new structure type. It has kind :attr:`TypeKind.STRUCT`.\n"
	"\n"
	":param tag: :attr:`Type.tag`\n"
	":param size: :attr:`Type.size`\n"
	":param members: :attr:`Type.members`\n"
	":param template_parameters: :attr:`Type.template_parameters`\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`\n"
	"\n"
	"struct_type(tag: Optional[str], size: None = None, members: None = None, *, template_parameters: Sequence[_drgn.TypeTemplateParameter] = (), qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new incomplete structure type.";
const char drgn_Program_union_type_DOC[] =
	"union_type(tag: Optional[str], size: _drgn.IntegerLike, members: Sequence[_drgn.TypeMember], *, template_parameters: Sequence[_drgn.TypeTemplateParameter] = (), qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new union type. It has kind :attr:`TypeKind.UNION`. Otherwise,\n"
	"this is the same as as :meth:`struct_type()`.\n"
	"\n"
	"union_type(tag: Optional[str], size: None = None, members: None = None, *, template_parameters: Sequence[_drgn.TypeTemplateParameter] = (), qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new incomplete union type.";
const char drgn_Program_class_type_DOC[] =
	"class_type(tag: Optional[str], size: _drgn.IntegerLike, members: Sequence[_drgn.TypeMember], *, template_parameters: Sequence[_drgn.TypeTemplateParameter] = (), qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new class type. It has kind :attr:`TypeKind.CLASS`. Otherwise,\n"
	"this is the same as as :meth:`struct_type()`.\n"
	"\n"
	"class_type(tag: Optional[str], size: None = None, members: None = None, *, template_parameters: Sequence[_drgn.TypeTemplateParameter] = (), qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new incomplete class type.";
const char drgn_Program_enum_type_DOC[] =
	"enum_type(tag: Optional[str], type: _drgn.Type, enumerators: Sequence[_drgn.TypeEnumerator], *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new enumerated type. It has kind :attr:`TypeKind.ENUM`.\n"
	"\n"
	":param tag: :attr:`Type.tag`\n"
	":param type: The compatible integer type (:attr:`Type.type`)\n"
	":param enumerators: :attr:`Type.enumerators`\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`\n"
	"\n"
	"enum_type(tag: Optional[str], type: None = None, enumerators: None = None, *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new incomplete enumerated type.";
const char drgn_Program_typedef_type_DOC[] =
	"typedef_type(name: str, type: _drgn.Type, *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new typedef type. It has kind :attr:`TypeKind.TYPEDEF`.\n"
	"\n"
	":param name: :attr:`Type.name`\n"
	":param type: The aliased type (:attr:`Type.type`)\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_Program_pointer_type_DOC[] =
	"pointer_type(type: _drgn.Type, size: Optional[int] = None, byteorder: Optional[str] = None, *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new pointer type. It has kind :attr:`TypeKind.POINTER`,\n"
	"\n"
	":param type: The referenced type (:attr:`Type.type`)\n"
	":param size: :attr:`Type.size`, or ``None`` to use the program's\n"
	"    default pointer size.\n"
	":param byteorder: :attr:`Type.byteorder`, or ``None`` to use the\n"
	"    program's default byte order.\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_Program_array_type_DOC[] =
	"array_type(type: _drgn.Type, length: Optional[int] = None, *, qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new array type. It has kind :attr:`TypeKind.ARRAY`.\n"
	"\n"
	":param type: The element type (:attr:`Type.type`)\n"
	":param length: :attr:`Type.length`\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_Program_function_type_DOC[] =
	"function_type(type: _drgn.Type, parameters: Sequence[_drgn.TypeParameter], is_variadic: bool = False, *, template_parameters: Sequence[_drgn.TypeTemplateParameter] = (), qualifiers: _drgn.Qualifiers = _drgn.Qualifiers.NONE, language: Optional[_drgn.Language] = None) -> _drgn.Type\n"
	"\n"
	"Create a new function type. It has kind :attr:`TypeKind.FUNCTION`.\n"
	"\n"
	":param type: The return type (:attr:`Type.type`)\n"
	":param parameters: :attr:`Type.parameters`\n"
	":param is_variadic: :attr:`Type.is_variadic`\n"
	":param template_parameters: :attr:`Type.template_parameters`\n"
	":param qualifiers: :attr:`Type.qualifiers`\n"
	":param lang: :attr:`Type.language`";
const char drgn_ProgramFlags_DOC[] =
	"Bases: enum.Flag\n"
	"\n"
	"``ProgramFlags`` are flags that can apply to a :class:`Program` (e.g.,\n"
	"about what kind of program it is).";
const char drgn_ProgramFlags_IS_LINUX_KERNEL_DOC[] =
	"The program is the Linux kernel.";
const char drgn_ProgramFlags_IS_LIVE_DOC[] =
	"The program is currently running (e.g., it is the running operating system\n"
	"kernel or a running process).";
const char drgn_ProgramFlags_IS_LOCAL_DOC[] =
	"The program is running on the local machine.";
const char drgn_FindObjectFlags_DOC[] =
	"Bases: enum.Flag\n"
	"\n"
	"``FindObjectFlags`` are flags for :meth:`Program.object()`. These can be\n"
	"combined to search for multiple kinds of objects at once.";
const char drgn_FindObjectFlags_CONSTANT_DOC[] = "";
const char drgn_FindObjectFlags_FUNCTION_DOC[] = "";
const char drgn_FindObjectFlags_VARIABLE_DOC[] = "";
const char drgn_FindObjectFlags_ANY_DOC[] = "";
const char drgn_ObjectNotFoundError_DOC[] =
	"Bases: KeyError\n"
	"\n"
	"ObjectNotFoundError(*args: object, name: str)\n"
	"\n"
	"Error raised when an object is not found in a program.";
const char drgn_ObjectNotFoundError_name_DOC[] =
	"str\n"
	"\n"
	"Object name that was not found.";
const char drgn_MemorySearchIterator_DOC[] =
	"Bases: Iterator[T]\n"
	"\n"
	"Iterator returned by :ref:`memory searches <api-searching-memory>`.";
const char drgn_MemorySearchIterator_set_address_range_DOC[] =
	"set_address_range(min_address: Optional[_drgn.IntegerLike] = None, max_address: Optional[_drgn.IntegerLike] = None, physical: bool = False) -> Self\n"
	"\n"
	"Set the address range to limit a memory search to.\n"
	"\n"
	"This returns the iterator itself, so it can be used conveniently when\n"
	"the iterator is created:\n"
	"\n"
	".. code-block:: python3\n"
	"\n"
	"    for address in search_memory(b\"VMCOREINFO\").set_address_range(physical=True):\n"
	"        print(hex(address))\n"
	"\n"
	"It can also be called during or after iteration, allowing an iterator\n"
	"to be reused for searching multiple ranges:\n"
	"\n"
	".. code-block:: python3\n"
	"\n"
	"    it = search_memory_regex(some_complex_pattern)\n"
	"\n"
	"    for min_address, max_address in address_ranges:\n"
	"        it.set_address_range(min_address, max_address)\n"
	"        for address, match in it:\n"
	"            print(hex(address), match)\n"
	"\n"
	":param min_address: Minimum address to search (inclusive). Defaults to\n"
	"    the program's minimum address.\n"
	":param max_address: Maximum address to search (inclusive). Defaults to\n"
	"    the program's maximum address.\n"
	":param physical: Whether to search physical memory. Defaults to\n"
	"    ``False`` (virtual memory).";
const char drgn_DebugInfoOptions_DOC[] =
	"Options for debugging information searches.\n"
	"\n"
	"All of these options can be reassigned.\n"
	"\n"
	"DebugInfoOptions(options: Optional[DebugInfoOptions] = None, /, *, directories: Iterable[Path] = ..., try_module_name: bool = ..., try_build_id: bool = ..., try_debug_link: bool = ..., try_procfs: bool = ..., try_embedded_vdso: bool = ..., try_reuse: bool = ..., try_supplementary: bool = ..., kernel_directories: Iterable[Path] = ..., try_kmod: KmodSearchMethod = ...)\n"
	"\n"
	"Create a ``DebugInfoOptions``.\n"
	"\n"
	":param options: If given, create a copy of the given options.\n"
	"    Otherwise, use the default options.\n"
	"\n"
	"Any remaining arguments override the copied/default options.";
const char drgn_DebugInfoOptions___new___DOC[] =
	"__new__(options: Optional[_drgn.DebugInfoOptions] = None, /, *, directories: Iterable[_drgn.Path] = ..., try_module_name: bool = ..., try_build_id: bool = ..., try_debug_link: bool = ..., try_procfs: bool = ..., try_embedded_vdso: bool = ..., try_reuse: bool = ..., try_supplementary: bool = ..., kernel_directories: Iterable[_drgn.Path] = ..., try_kmod: _drgn.KmodSearchMethod = ...) -> Self\n"
	"\n"
	"Create a ``DebugInfoOptions``.\n"
	"\n"
	":param options: If given, create a copy of the given options.\n"
	"    Otherwise, use the default options.\n"
	"\n"
	"Any remaining arguments override the copied/default options.";
const char drgn_DebugInfoOptions_directories_DOC[] =
	"Tuple[str, ...]\n"
	"\n"
	"Directories to search for debugging information files.\n"
	"\n"
	"Defaults to ``(\"/usr/lib/debug\",)``, which should work out of the box on\n"
	"most Linux distributions. Empty strings are not allowed.\n"
	"\n"
	"By default, this is used for searches by build ID (see\n"
	":attr:`try_build_id`), debug link (see :attr:`debug_link_directories`), for\n"
	"supplementary files (see :attr:`try_supplementary`), and for kernel files\n"
	"(see :attr:`kernel_directories`).";
const char drgn_DebugInfoOptions_try_module_name_DOC[] =
	"bool\n"
	"\n"
	"If the name of a module resembles a filesystem path, try the file at that\n"
	"path.\n"
	"\n"
	"Defaults to ``True``.";
const char drgn_DebugInfoOptions_try_build_id_DOC[] =
	"bool\n"
	"\n"
	"Try finding files using build IDs.\n"
	"\n"
	"Defaults to ``True``.\n"
	"\n"
	"A *build ID* is a unique byte string present in a module's :ref:`loaded\n"
	"file <module-loaded-file>` and :ref:`debug file <module-debug-file>`. If\n"
	"configured correctly, it is also present in core dumps and provides a\n"
	"reliable way to identify the correct files for a module.\n"
	"\n"
	"Searches by build ID check under each path in :attr:`directories` for a\n"
	"file named ``.build-id/xx/yyyy`` (for loaded files) or\n"
	"``.build-id/xx/yyyy.debug`` (for debug files), where ``xxyyyy`` is the\n"
	"lowercase hexadecimal representation of the build ID.";
const char drgn_DebugInfoOptions_debug_link_directories_DOC[] =
	"Tuple[str, ...]\n"
	"\n"
	"Directories to search for debug links.\n"
	"\n"
	"Defaults to ``(\"$ORIGIN\", \"$ORIGIN/.debug\", \"\")``, which should work out of\n"
	"the box on most Linux distributions.\n"
	"\n"
	"``$ORIGIN`` (or ``${ORIGIN}``) is replaced with the absolute path of the\n"
	"directory containing the loaded file. An empty string means to check under\n"
	"each path in :attr:`directories` (i.e., ``path$ORIGIN`` for each path in\n"
	":attr:`directories`).\n"
	"\n"
	"See :attr:`try_debug_link`.";
const char drgn_DebugInfoOptions_try_debug_link_DOC[] =
	"bool\n"
	"\n"
	"Try finding files using debug links.\n"
	"\n"
	"Defaults to ``True``.\n"
	"\n"
	"A *debug link* is a pointer in a module's :ref:`loaded file\n"
	"<module-loaded-file>` to its :ref:`debug file <module-debug-file>`. It\n"
	"consists of a name and a checksum.\n"
	"\n"
	"Searches by debug link check every path in :attr:`debug_link_directories`\n"
	"for a file with a matching name and checksum.";
const char drgn_DebugInfoOptions_try_procfs_DOC[] =
	"bool\n"
	"\n"
	"For local processes, try getting files via the ``proc`` filesystem (e.g.,\n"
	":manpage:`proc_pid_exe(5)`, :manpage:`proc_pid_map_files(5)`).\n"
	"\n"
	"Defaults to ``True``.";
const char drgn_DebugInfoOptions_try_embedded_vdso_DOC[] =
	"bool\n"
	"\n"
	"Try reading the vDSO embedded in a process's memory/core dump.\n"
	"\n"
	"Defaults to ``True``.\n"
	"\n"
	"The entire (stripped) vDSO is included in core dumps, so this is a reliable\n"
	"way to get it.";
const char drgn_DebugInfoOptions_try_reuse_DOC[] =
	"bool\n"
	"\n"
	"Try reusing a module's loaded file as its debug file and vice versa.\n"
	"\n"
	"Defaults to ``True``.";
const char drgn_DebugInfoOptions_try_supplementary_DOC[] =
	"bool\n"
	"\n"
	"Try finding :ref:`supplementary files <module-supplementary-debug-file>`.\n"
	"\n"
	"Defaults to ``True``.";
const char drgn_DebugInfoOptions_kernel_directories_DOC[] =
	"Tuple[str, ...]\n"
	"\n"
	"Directories to search for the kernel image and loadable kernel modules.\n"
	"\n"
	"Defaults to ``(\"\",)``.\n"
	"\n"
	"An empty string means to check standard paths (e.g.,\n"
	":file:`/boot/vmlinux-{release}`, :file:`/lib/modules/{release}`) absolutely\n"
	"and under each path in :attr:`directories`.";
const char drgn_DebugInfoOptions_try_kmod_DOC[] =
	"_drgn.KmodSearchMethod\n"
	"\n"
	"How to search for loadable kernel modules.\n"
	"\n"
	"Defaults to :attr:`KmodSearchMethod.DEPMOD_OR_WALK`.";
const char drgn_KmodSearchMethod_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"Methods of searching for loadable kernel module debugging information.\n"
	"\n"
	"In addition to searching by build ID, there are currently two methods of\n"
	"searching for debugging information specific to loadable kernel modules:\n"
	"\n"
	"1. Using :manpage:`depmod(8)` metadata. This looks for :command:`depmod`\n"
	"   metadata (specifically, :file:`modules.dep.bin`) at the top level of\n"
	"   each directory in :attr:`DebugInfoOptions.kernel_directories` (an empty\n"
	"   path means :file:`/lib/modules/{release}`). The metadata is used to\n"
	"   quickly find the path of each module, which is then checked relative to\n"
	"   each directory specified by :attr:`DebugInfoOptions.kernel_directories`.\n"
	"\n"
	"   This method is faster but typically only applicable to installed\n"
	"   kernels.\n"
	"2. Walking kernel directories. This traverses each directory specified by\n"
	"   :attr:`DebugInfoOptions.kernel_directories` looking for ``.ko`` files.\n"
	"   Module names are matched to filenames before the ``.ko`` extension and\n"
	"   with dashes (``-``) replaced with underscores (``_``).\n"
	"\n"
	"   This method is slower but not limited to installed kernels.\n"
	"\n"
	"Debugging information searches can be configured to use one, both, or\n"
	"neither method.";
const char drgn_KmodSearchMethod_NONE_DOC[] =
	"Don't search using kernel module-specific methods.";
const char drgn_KmodSearchMethod_DEPMOD_DOC[] =
	"Search using :command:`depmod` metadata.";
const char drgn_KmodSearchMethod_WALK_DOC[] =
	"Search by walking kernel directories.";
const char drgn_KmodSearchMethod_DEPMOD_OR_WALK_DOC[] =
	"Search using :command:`depmod` metadata, falling back to walking kernel\n"
	"directories only if no :command:`depmod` metadata is found.\n"
	"\n"
	"Since :command:`depmod` metadata is expected to be reliable if present,\n"
	"this is the default.";
const char drgn_KmodSearchMethod_DEPMOD_AND_WALK_DOC[] =
	"Search using :command:`depmod` metadata and by walking kernel directories.\n"
	"\n"
	"Unlike :attr:`DEPMOD_OR_WALK`, if :command:`depmod` metadata is found but\n"
	"doesn't result in the desired debugging information, this will still walk\n"
	"kernel directories.";
const char drgn_get_default_prog_DOC[] =
	"get_default_prog() -> Program\n"
	"\n"
	"Get the default program for the current thread.\n"
	"\n"
	":raises NoDefaultProgramError: if the default program is not set";
const char drgn_set_default_prog_DOC[] =
	"set_default_prog(prog: Optional[Program], /) -> None\n"
	"\n"
	"Set the default program for the current thread.\n"
	"\n"
	":param prog: Program to set as the default, or ``None`` to unset it.";
const char drgn_NoDefaultProgramError_DOC[] =
	"Bases: Exception\n"
	"\n"
	"Error raised when trying to use the default program when it is not set.";
const char drgn_Module_DOC[] =
	"A ``Module`` represents an executable, library, or other binary file used\n"
	"by a program. It has several subclasses representing specific types of\n"
	"modules.\n"
	"\n"
	"Modules are uniquely identified by their type, name, and a type-specific\n"
	"value.\n"
	"\n"
	"Modules have several attributes that are determined automatically whenever\n"
	"possible but may be overridden manually if needed.\n"
	"\n"
	"Modules can be assigned files that provide debugging and runtime\n"
	"information:\n"
	"\n"
	"* .. _module-loaded-file:\n"
	"\n"
	"  The \"loaded file\" is the file containing the executable code, data, etc.\n"
	"  used by the program at runtime.\n"
	"\n"
	"\n"
	"* .. _module-debug-file:\n"
	"\n"
	"  The \"debug file\" is the file containing debugging information (e.g.,\n"
	"  `DWARF <https://dwarfstd.org/>`_).\n"
	"\n"
	"  The loaded file and debug file may be the same file, for example, an\n"
	"  unstripped binary. They may be different files if the binary was stripped\n"
	"  and its debugging information was split into a separate file.\n"
	"\n"
	"\n"
	"* .. _module-supplementary-debug-file:\n"
	"\n"
	"  The debug file may depend on a \"supplementary debug file\" such as one\n"
	"  generated by `dwz(1) <https://manpages.debian.org/dwz.1.html>`_. If so,\n"
	"  then the supplementary debug file must be found before the debug file can\n"
	"  be used.";
const char drgn_Module_prog_DOC[] =
	"Final[_drgn.Program]\n"
	"\n"
	"Program that this module is from.";
const char drgn_Module_name_DOC[] =
	"Final[str]\n"
	"\n"
	"Name of this module.\n"
	"\n"
	"Its exact meaning varies by module type.";
const char drgn_Module_address_ranges_DOC[] =
	"Optional[Sequence[Tuple[int, int]]]\n"
	"\n"
	"Address ranges where this module is loaded.\n"
	"\n"
	"This is a sequence of tuples of the start (inclusive) and end (exclusive)\n"
	"addresses. For each range, the start address is strictly less than the end\n"
	"address. If the module is not loaded in memory, then the sequence is empty.\n"
	"Address ranges may not overlap.\n"
	"\n"
	"If not known yet, then this is ``None``.\n"
	"\n"
	":meth:`Program.loaded_modules()` sets this automatically from the program\n"
	"state/core dump when possible. Otherwise, for :class:`MainModule`,\n"
	":class:`SharedLibraryModule`, and :class:`VdsoModule`, it may be set\n"
	"automatically when a file is assigned to the module. It is never set\n"
	"automatically for :class:`ExtraModule`. It can also be set manually.\n"
	"\n"
	"Other than Linux kernel loadable modules, most modules have only one\n"
	"address range. See :attr:`address_range`.";
const char drgn_Module_address_range_DOC[] =
	"Optional[Tuple[int, int]]\n"
	"\n"
	"Address range where this module is loaded.\n"
	"\n"
	"This is an alias of :attr:`address_ranges[0] <address_ranges>` with a\n"
	"couple of small differences:\n"
	"\n"
	"* If the module has more than one address range, then reading this raises a\n"
	"  :class:`ValueError`.\n"
	"* If the module is not loaded in memory, then this is ``(0, 0)``.";
const char drgn_Module_build_id_DOC[] =
	"Optional[bytes]\n"
	"\n"
	"Unique byte string (e.g., GNU build ID) identifying files used by this\n"
	"module.\n"
	"\n"
	"If not known, then this is ``None``.\n"
	"\n"
	":meth:`Program.loaded_modules()` sets this automatically from the program\n"
	"state/core dump when possible. Otherwise, when a file is assigned to the\n"
	"module, it is set to the file's build ID if it is not already set. It can\n"
	"also be set manually.";
const char drgn_Module_object_DOC[] =
	"_drgn.Object\n"
	"\n"
	"The object associated with this module.\n"
	"\n"
	"For Linux kernel loadable modules, this is the ``struct module *``\n"
	"associated with the kernel module. For other kinds, this is currently an\n"
	"absent object. The object may be set manually.";
const char drgn_Module_loaded_file_status_DOC[] =
	"_drgn.ModuleFileStatus\n"
	"\n"
	"Status of the module's :ref:`loaded file <module-loaded-file>`.";
const char drgn_Module_loaded_file_path_DOC[] =
	"Optional[str]\n"
	"\n"
	"Absolute path of the module's :ref:`loaded file <module-loaded-file>`, or\n"
	"``None`` if not known.";
const char drgn_Module_loaded_file_bias_DOC[] =
	"Optional[int]\n"
	"\n"
	"Difference between the load address in the program and addresses in the\n"
	":ref:`loaded file <module-loaded-file>` itself.\n"
	"\n"
	"This is often non-zero due to address space layout randomization (ASLR).\n"
	"\n"
	"It is set automatically based on the module type when the loaded file is\n"
	"added:\n"
	"\n"
	"* For :class:`MainModule`, it is set based on metadata from the process or\n"
	"  core dump (the `auxiliary vector\n"
	"  <https://man7.org/linux/man-pages/man3/getauxval.3.html>`_ for userspace\n"
	"  programs, the ``VMCOREINFO`` note for the Linux kernel).\n"
	"* For :class:`SharedLibraryModule` and :class:`VdsoModule`, it is set to\n"
	"  :attr:`~SharedLibraryModule.dynamic_address` minus the address of the\n"
	"  dynamic section in the file.\n"
	"* For :class:`RelocatableModule`, it is set to zero. Addresses are adjusted\n"
	"  according to :attr:`~RelocatableModule.section_addresses` instead.\n"
	"* For :class:`ExtraModule`, if :attr:`~Module.address_ranges` is set to a\n"
	"  single range before the file is added, then the bias is set to\n"
	"  :attr:`address_ranges[0][0] <Module.address_ranges>` (i.e., the module's\n"
	"  start address) minus the file's start address. If\n"
	"  :attr:`~Module.address_ranges` is not set when the file is added, is\n"
	"  empty, or comprises more than one range, then the bias is set to zero.\n"
	"\n"
	"This cannot be set manually.";
const char drgn_Module_debug_file_status_DOC[] =
	"_drgn.ModuleFileStatus\n"
	"\n"
	"Status of the module's :ref:`debug file <module-debug-file>`.";
const char drgn_Module_debug_file_path_DOC[] =
	"Optional[str]\n"
	"\n"
	"Absolute path of the module's :ref:`debug file <module-debug-file>`, or\n"
	"``None`` if not known.";
const char drgn_Module_debug_file_bias_DOC[] =
	"Optional[int]\n"
	"\n"
	"Difference between the load address in the program and addresses in the\n"
	":ref:`debug file <module-debug-file>`.\n"
	"\n"
	"See :attr:`loaded_file_bias`.";
const char drgn_Module_supplementary_debug_file_kind_DOC[] =
	"Optional[_drgn.SupplementaryFileKind]\n"
	"\n"
	"Kind of the module's :ref:`supplementary debug file\n"
	"<module-supplementary-debug-file>`, or ``None`` if not known or not needed.";
const char drgn_Module_supplementary_debug_file_path_DOC[] =
	"Optional[str]\n"
	"\n"
	"Absolute path of the module's :ref:`supplementary debug file\n"
	"<module-supplementary-debug-file>`, or ``None`` if not known or not needed.";
const char drgn_Module_wants_loaded_file_DOC[] =
	"wants_loaded_file() -> bool\n"
	"\n"
	"Return whether this module wants a :ref:`loaded file\n"
	"<module-loaded-file>`.\n"
	"\n"
	"This should be preferred over checking :attr:`loaded_file_status`\n"
	"directly since this is future-proof against new status types being\n"
	"added. It is currently equivalent to ``module.loaded_file_status ==\n"
	"ModuleFileStatus.WANT``.";
const char drgn_Module_wants_debug_file_DOC[] =
	"wants_debug_file() -> bool\n"
	"\n"
	"Return whether this module wants a :ref:`debug file\n"
	"<module-debug-file>`.\n"
	"\n"
	"This should be preferred over checking :attr:`debug_file_status`\n"
	"directly since this is future-proof against new status types being\n"
	"added. It is currently equivalent to ``module.debug_file_status ==\n"
	"ModuleFileStatus.WANT or module.debug_file_status ==\n"
	"ModuleFileStatus.WANT_SUPPLEMENTARY``.";
const char drgn_Module_wanted_supplementary_debug_file_DOC[] =
	"wanted_supplementary_debug_file() -> _drgn.WantedSupplementaryFile\n"
	"\n"
	"Return information about the :ref:`supplementary debug file\n"
	"<module-supplementary-debug-file>` that this module currently wants.\n"
	"\n"
	":raises ValueError: if the module doesn't currently want a\n"
	"    supplementary debug file (i.e., ``module.debug_file_status !=\n"
	"    ModuleFileStatus.WANT_SUPPLEMENTARY``)";
const char drgn_Module_try_file_DOC[] =
	"try_file(path: _drgn.Path, *, fd: int = -1, force: bool = False) -> None\n"
	"\n"
	"Try to use the given file for this module.\n"
	"\n"
	"If the file does not appear to belong to this module, then it is\n"
	"ignored. This currently checks that the file and the module have the\n"
	"same build ID.\n"
	"\n"
	"If :attr:`loaded_file_status` is :attr:`~ModuleFileStatus.WANT` and the\n"
	"file is loadable, then it is used as the :ref:`loaded file\n"
	"<module-loaded-file>` and :attr:`loaded_file_status` is set to\n"
	":attr:`~ModuleFileStatus.HAVE`.\n"
	"\n"
	"If :attr:`debug_file_status` is :attr:`~ModuleFileStatus.WANT` or\n"
	":attr:`~ModuleFileStatus.WANT_SUPPLEMENTARY` and the file provides\n"
	"debugging information, then it is used as the :ref:`debug file\n"
	"<module-debug-file>` and :attr:`debug_file_status` is set to\n"
	":attr:`~ModuleFileStatus.HAVE`. However, if the file requires a\n"
	"supplementary debug file, then it is not used as the debug file yet and\n"
	":attr:`debug_file_status` is set to\n"
	":attr:`~ModuleFileStatus.WANT_SUPPLEMENTARY` instead.\n"
	"\n"
	"If :attr:`debug_file_status` is\n"
	":attr:`~ModuleFileStatus.WANT_SUPPLEMENTARY` and the file matches\n"
	":meth:`wanted_supplementary_debug_file()`, then the previously found\n"
	"file is used as the debug file, the given file is used as the\n"
	":ref:`supplementary debug file <module-supplementary-debug-file>`, and\n"
	":attr:`debug_file_status` is set to :attr:`~ModuleFileStatus.HAVE`.\n"
	"\n"
	"The file may be used as both the loaded file and debug file if\n"
	"applicable.\n"
	"\n"
	":param path: Path to file.\n"
	":param fd: If nonnegative, an open file descriptor referring to the\n"
	"    file. This always takes ownership of the file descriptor even if\n"
	"    the file is not used or on error, so the caller must not close it.\n"
	":param force: If ``True``, then don't check whether the file matches\n"
	"    the module.";
const char drgn_MainModule_DOC[] =
	"Bases: Module\n"
	"\n"
	"Main module.\n"
	"\n"
	"There is only one main module in a program. For userspace programs, it is\n"
	"the executable, and its name is usually the absolute path of the\n"
	"executable. For the Linux kernel, it is the kernel image, a.k.a.\n"
	"``vmlinux``, and its name is \"kernel\".";
const char drgn_SharedLibraryModule_DOC[] =
	"Bases: Module\n"
	"\n"
	"Shared library (a.k.a. dynamic library, dynamic shared object, or ``.so``)\n"
	"module.\n"
	"\n"
	"Shared libraries are uniquely identified by their name (usually the\n"
	"absolute path of the shared object file) and dynamic address.";
const char drgn_SharedLibraryModule_dynamic_address_DOC[] =
	"Final[int]\n"
	"\n"
	"Address of the shared object's dynamic section.";
const char drgn_VdsoModule_DOC[] =
	"Bases: Module\n"
	"\n"
	"Virtual dynamic shared object (vDSO) module.\n"
	"\n"
	"The vDSO is a special shared library automatically loaded into a process by\n"
	"the kernel; see :manpage:`vdso(7)`. It is uniquely identified by its name\n"
	"(the ``SONAME`` field of the shared object file) and dynamic address.";
const char drgn_VdsoModule_dynamic_address_DOC[] =
	"Final[int]\n"
	"\n"
	"Address of the shared object's dynamic section.";
const char drgn_RelocatableModule_DOC[] =
	"Bases: Module\n"
	"\n"
	"Relocatable object module.\n"
	"\n"
	"A relocatable object is an object file requiring a linking step to assign\n"
	"section addresses and adjust the file to reference those addresses.\n"
	"\n"
	"Linux kernel loadable modules (``.ko`` files) are a special kind of\n"
	"relocatable object.\n"
	"\n"
	"For userspace programs, relocatable objects are usually intermediate\n"
	"products of the compilation process (``.o`` files). They are not typically\n"
	"loaded at runtime. However, drgn allows manually defining a relocatable\n"
	"module and assigning its section addresses if needed.\n"
	"\n"
	"Relocatable modules are uniquely identified by a name and address.";
const char drgn_RelocatableModule_address_DOC[] =
	"Final[int]\n"
	"\n"
	"Address identifying the module.\n"
	"\n"
	"For Linux kernel loadable modules, this is the module base address.";
const char drgn_RelocatableModule_section_addresses_DOC[] =
	"MutableMapping[str, int]\n"
	"\n"
	"Mapping from section names to assigned addresses.\n"
	"\n"
	"Once a file has been assigned to the module, this can no longer be\n"
	"modified.\n"
	"\n"
	":meth:`Program.linux_kernel_loadable_module()` and\n"
	":meth:`Program.loaded_modules()` prepopulate this for Linux kernel loadable\n"
	"modules.";
const char drgn_ExtraModule_DOC[] =
	"Bases: Module\n"
	"\n"
	"Module with extra debugging information.\n"
	"\n"
	"For advanced use cases, it may be necessary to manually add debugging\n"
	"information that does not fit into any of the categories above.\n"
	"``ExtraModule`` is intended for these use cases. For example, it can be\n"
	"used to add debugging information from a standalone file that is not in use\n"
	"by a particular program.\n"
	"\n"
	"Extra modules are uniquely identified by a name and ID number. Both the\n"
	"name and ID number are arbitrary.";
const char drgn_ExtraModule_id_DOC[] =
	"Final[int]\n"
	"\n"
	"Arbitrary identification number.";
const char drgn_ModuleFileStatus_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"Status of a file in a :class:`Module`.\n"
	"\n"
	"This is usually used to communicate with debugging information finders; see\n"
	":meth:`Program.register_debug_info_finder()`.";
const char drgn_ModuleFileStatus_WANT_DOC[] =
	"File has not been found and should be searched for.";
const char drgn_ModuleFileStatus_HAVE_DOC[] =
	"File has already been found and assigned.";
const char drgn_ModuleFileStatus_DONT_WANT_DOC[] =
	"File has not been found, but it should not be searched for.\n"
	"\n"
	":meth:`Module.try_file()` and debugging information finders are required to\n"
	"honor this and will never change it. However, other operations may reset\n"
	"this to :attr:`WANT` when they load debugging information automatically.";
const char drgn_ModuleFileStatus_DONT_NEED_DOC[] =
	"File has not been found and is not needed (e.g., because its debugging\n"
	"information is not applicable or is provided through another mechanism).\n"
	"\n"
	"In contrast to :attr:`DONT_WANT`, drgn itself will never change this to\n"
	":attr:`WANT`.";
const char drgn_ModuleFileStatus_WANT_SUPPLEMENTARY_DOC[] =
	"File has been found, but it requires a supplementary file before it can be\n"
	"used. See :meth:`Module.wanted_supplementary_debug_file()`.";
const char drgn_WantedSupplementaryFile_DOC[] =
	"Bases: NamedTuple\n"
	"\n"
	"Information about a wanted supplementary file.";
const char drgn_WantedSupplementaryFile_kind_DOC[] =
	"_drgn.SupplementaryFileKind\n"
	"\n"
	"Kind of supplementary file.";
const char drgn_WantedSupplementaryFile_path_DOC[] =
	"str\n"
	"\n"
	"Path of main file that wants the supplementary file.";
const char drgn_WantedSupplementaryFile_supplementary_path_DOC[] =
	"str\n"
	"\n"
	"Path to the supplementary file.\n"
	"\n"
	"This may be absolute or relative to :attr:`path`.";
const char drgn_WantedSupplementaryFile_checksum_DOC[] =
	"bytes\n"
	"\n"
	"Unique identifier of the supplementary file.\n"
	"\n"
	"The interpretation depends on :attr:`kind`.";
const char drgn_SupplementaryFileKind_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"Kind of supplementary file.\n"
	"\n"
	".. note::\n"
	"    DWARF 5 supplementary files are not currently supported but may be in\n"
	"    the future.\n"
	"\n"
	"    DWARF package files are not considered supplementary files. They are\n"
	"    considered part of the debug file and must have the same path as the\n"
	"    debug file plus a \".dwp\" extension.";
const char drgn_SupplementaryFileKind_GNU_DEBUGALTLINK_DOC[] =
	"GNU-style supplementary debug file referred to by a ``.gnu_debugaltlink``\n"
	"section.\n"
	"\n"
	"Its :attr:`~WantedSupplementaryFile.checksum` is the file's GNU build ID.";
const char drgn_Thread_DOC[] =
	"A thread in a program.";
const char drgn_Thread_tid_DOC[] =
	"Final[int]\n"
	"\n"
	"Thread ID (as defined by :manpage:`gettid(2)`).";
const char drgn_Thread_name_DOC[] =
	"Optional[str]\n"
	"\n"
	"Thread name, or ``None`` if unknown.\n"
	"\n"
	"See `PR_SET_NAME\n"
	"<https://man7.org/linux/man-pages/man2/PR_SET_NAME.2const.html>`_ and\n"
	"`/proc/pid/comm\n"
	"<https://man7.org/linux/man-pages/man5/proc_pid_comm.5.html>`_.\n"
	"\n"
	".. note::\n"
	"    Linux userspace core dumps only save the name of the main thread, so\n"
	"    :attr:`name` will be ``None`` for other threads.";
const char drgn_Thread_object_DOC[] =
	"Final[_drgn.Object]\n"
	"\n"
	"If the program is the Linux kernel, the ``struct task_struct *`` object for\n"
	"this thread. Otherwise, not defined.";
const char drgn_Thread_stack_trace_DOC[] =
	"stack_trace() -> _drgn.StackTrace\n"
	"\n"
	"Get the stack trace for this thread.\n"
	"\n"
	"This is equivalent to ``prog.stack_trace(thread.tid)``. See\n"
	":meth:`Program.stack_trace()`.";
const char drgn_filename_matches_DOC[] =
	"filename_matches(haystack: Optional[str], needle: Optional[str]) -> bool\n"
	"\n"
	"Return whether a filename containing a definition (*haystack*) matches a\n"
	"filename being searched for (*needle*).\n"
	"\n"
	"The filename is matched from right to left, so ``'stdio.h'``,\n"
	"``'include/stdio.h'``, ``'usr/include/stdio.h'``, and\n"
	"``'/usr/include/stdio.h'`` would all match a definition in\n"
	"``/usr/include/stdio.h``. If *needle* is ``None`` or empty, it matches any\n"
	"definition. If *haystack* is ``None`` or empty, it only matches if *needle*\n"
	"is also ``None`` or empty.\n"
	"\n"
	":param haystack: Path of file containing definition.\n"
	":param needle: Filename to match.";
const char drgn_program_from_core_dump_DOC[] =
	"program_from_core_dump(path: Union[Path, int]) -> Program\n"
	"\n"
	"Create a :class:`Program` from a core dump file. The type of program (e.g.,\n"
	"userspace or kernel) is determined automatically.\n"
	"\n"
	":param path: Core dump file path or open file descriptor.";
const char drgn_program_from_kernel_DOC[] =
	"program_from_kernel() -> Program\n"
	"\n"
	"Create a :class:`Program` from the running operating system kernel. This\n"
	"requires root privileges.";
const char drgn_program_from_pid_DOC[] =
	"program_from_pid(pid: int) -> Program\n"
	"\n"
	"Create a :class:`Program` from a running program with the given PID. This\n"
	"requires appropriate permissions (on Linux, :manpage:`ptrace(2)` attach\n"
	"permissions).\n"
	"\n"
	":param pid: Process ID of the program to debug.";
const char drgn_Platform_DOC[] =
	"A ``Platform`` represents the environment (i.e., architecture and ABI) that\n"
	"a program runs on.\n"
	"\n"
	"Platform(arch: Architecture, flags: Optional[PlatformFlags] = None)\n"
	"\n"
	"Create a ``Platform``.\n"
	"\n"
	":param arch: :attr:`Platform.arch`\n"
	":param flags: :attr:`Platform.flags`; if ``None``, default flags for\n"
	"    the architecture are used.";
const char drgn_Platform___new___DOC[] =
	"__new__(arch: _drgn.Architecture, flags: Optional[_drgn.PlatformFlags] = None) -> Self\n"
	"\n"
	"Create a ``Platform``.\n"
	"\n"
	":param arch: :attr:`Platform.arch`\n"
	":param flags: :attr:`Platform.flags`; if ``None``, default flags for\n"
	"    the architecture are used.";
const char drgn_Platform_arch_DOC[] =
	"Final[_drgn.Architecture]\n"
	"\n"
	"Instruction set architecture of this platform.";
const char drgn_Platform_flags_DOC[] =
	"Final[_drgn.PlatformFlags]\n"
	"\n"
	"Flags which apply to this platform.";
const char drgn_Platform_registers_DOC[] =
	"Final[Sequence[_drgn.Register]]\n"
	"\n"
	"Processor registers on this platform.";
const char drgn_Architecture_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"An ``Architecture`` represents an instruction set architecture.";
const char drgn_Architecture_X86_64_DOC[] =
	"The x86-64 architecture, a.k.a. AMD64 or Intel 64.";
const char drgn_Architecture_I386_DOC[] =
	"The 32-bit x86 architecture, a.k.a. i386 or IA-32.";
const char drgn_Architecture_AARCH64_DOC[] =
	"The AArch64 architecture, a.k.a. ARM64.";
const char drgn_Architecture_ARM_DOC[] =
	"The 32-bit Arm architecture.";
const char drgn_Architecture_PPC64_DOC[] =
	"The 64-bit PowerPC architecture.";
const char drgn_Architecture_RISCV64_DOC[] =
	"The 64-bit RISC-V architecture.";
const char drgn_Architecture_RISCV32_DOC[] =
	"The 32-bit RISC-V architecture.";
const char drgn_Architecture_S390X_DOC[] =
	"The s390x architecture, a.k.a. IBM Z or z/Architecture.";
const char drgn_Architecture_S390_DOC[] =
	"The 32-bit s390 architecture, a.k.a. System/390.";
const char drgn_Architecture_UNKNOWN_DOC[] =
	"An architecture which is not known to drgn. Certain features are not\n"
	"available when the architecture is unknown, but most of drgn will still\n"
	"work.";
const char drgn_PlatformFlags_DOC[] =
	"Bases: enum.Flag\n"
	"\n"
	"``PlatformFlags`` are flags describing a :class:`Platform`.";
const char drgn_PlatformFlags_IS_64_BIT_DOC[] =
	"Platform is 64-bit.";
const char drgn_PlatformFlags_IS_LITTLE_ENDIAN_DOC[] =
	"Platform is little-endian.";
const char drgn_Register_DOC[] =
	"A ``Register`` represents information about a processor register.";
const char drgn_Register_names_DOC[] =
	"Final[Sequence[str]]\n"
	"\n"
	"Names of this register.";
const char drgn_host_platform_DOC[] =
	"Platform\n"
	"\n"
	"The platform of the host which is running drgn.";
const char drgn_Language_DOC[] =
	"A ``Language`` represents a programming language supported by drgn.\n"
	"\n"
	"This class cannot be constructed; there are singletons for the supported\n"
	"languages.";
const char drgn_Language_name_DOC[] =
	"Final[str]\n"
	"\n"
	"Name of the programming language.";
const char drgn_Language_C_DOC[] =
	"ClassVar[_drgn.Language]\n"
	"\n"
	"The C programming language.";
const char drgn_Language_CPP_DOC[] =
	"ClassVar[_drgn.Language]\n"
	"\n"
	"The C++ programming language.";
const char drgn_Object_DOC[] =
	"An ``Object`` represents a symbol or value in a program. An object may\n"
	"exist in the memory of the program (a *reference*), it may be a constant or\n"
	"temporary computed value (a *value*), or it may be absent entirely (an\n"
	"*absent* object).\n"
	"\n"
	"All instances of this class have two attributes: :attr:`prog_`, the program\n"
	"that the object is from; and :attr:`type_`, the type of the object.\n"
	"Reference objects also have an :attr:`address_` and a :attr:`bit_offset_`.\n"
	"Objects may also have a :attr:`bit_field_size_`.\n"
	"\n"
	":func:`repr()` of an object returns a Python representation of the object:\n"
	"\n"
	">>> print(repr(prog['jiffies']))\n"
	"Object(prog, 'volatile unsigned long', address=0xffffffffbf005000)\n"
	"\n"
	":class:`str() <str>` returns a \"pretty\" representation of the object in\n"
	"programming language syntax:\n"
	"\n"
	">>> print(prog['jiffies'])\n"
	"(volatile unsigned long)4326237045\n"
	"\n"
	"The output format of ``str()`` can be modified by using the\n"
	":meth:`format_()` method instead:\n"
	"\n"
	">>> sysname = prog['init_uts_ns'].name.sysname\n"
	">>> print(sysname)\n"
	"(char [65])\"Linux\"\n"
	">>> print(sysname.format_(type_name=False))\n"
	"\"Linux\"\n"
	">>> print(sysname.format_(string=False))\n"
	"(char [65]){ 76, 105, 110, 117, 120 }\n"
	"\n"
	".. note::\n"
	"\n"
	"    The drgn CLI is set up so that objects are displayed in the \"pretty\"\n"
	"    format instead of with ``repr()`` (the latter is the default behavior\n"
	"    of Python's interactive mode). Therefore, it's usually not necessary to\n"
	"    call ``print()`` in the drgn CLI.\n"
	"\n"
	"Objects support the following operators:\n"
	"\n"
	"* Arithmetic operators: ``+``, ``-``, ``*``, ``/``, ``%``\n"
	"* Bitwise operators: ``<<``, ``>>``, ``&``, ``|``, ``^``, ``~``\n"
	"* Relational operators: ``==``, ``!=``, ``<``, ``>``, ``<=``, ``>=``\n"
	"* Subscripting: :meth:`[] <__getitem__>` (Python does not have a unary\n"
	"  ``*`` operator, so pointers are dereferenced with ``ptr[0]``)\n"
	"* Member access: :meth:`. <__getattr__>` (Python does not have a ``->``\n"
	"  operator, so ``.`` is also used to access members of pointers to\n"
	"  structures)\n"
	"* The address-of operator: :meth:`drgn.Object.address_of_()` (this is a\n"
	"  method because Python does not have a ``&`` operator)\n"
	"* Array length: :meth:`len() <__len__>`\n"
	"\n"
	"These operators all have the semantics of the program's programming\n"
	"language. For example, adding two objects from a program written in C\n"
	"results in an object with a type and value according to the rules of C:\n"
	"\n"
	">>> Object(prog, 'unsigned long', 2**64 - 1) + Object(prog, 'int', 1)\n"
	"Object(prog, 'unsigned long', value=0)\n"
	"\n"
	"If only one operand to a binary operator is an object, the other operand\n"
	"will be converted to an object according to the language's rules for\n"
	"literals:\n"
	"\n"
	">>> Object(prog, 'char', 0) - 1\n"
	"Object(prog, 'int', value=-1)\n"
	"\n"
	"The standard :class:`int() <int>`, :class:`float() <float>`, and\n"
	":class:`bool() <bool>` functions convert an object to that Python type.\n"
	"Conversion to ``bool`` uses the programming language's notion of\n"
	"\"truthiness\". Additionally, certain Python functions will automatically\n"
	"coerce an object to the appropriate Python type (e.g., :func:`hex()`,\n"
	":func:`round()`, and :meth:`list subscripting <object.__getitem__>`).\n"
	"\n"
	"Object attributes and methods are named with a trailing underscore to avoid\n"
	"conflicting with structure, union, or class members. The attributes and\n"
	"methods always take precedence; use :meth:`member_()` if there is a\n"
	"conflict.\n"
	"\n"
	"Objects are usually obtained directly from a :class:`Program`, but they can\n"
	"be constructed manually, as well (for example, if you got a variable\n"
	"address from a log file).\n"
	"\n"
	"Object(prog: Program, type: Union[str, Type], value: Union[IntegerLike, float, bool, Mapping[str, Any], Sequence[Any]], *, bit_field_size: Optional[IntegerLike] = None)\n"
	"\n"
	"Create a value object given its type and value.\n"
	"\n"
	":param prog: Program to create the object in.\n"
	":param type: Type of the object.\n"
	":param value: Value of the object. See :meth:`value_()`.\n"
	":param bit_field_size: Size in bits of the object if it is a bit field.\n"
	"    The default is ``None``, which means the object is not a bit field.\n"
	"\n"
	"Object(prog: Program, *, value: Union[int, float, bool])\n"
	"\n"
	"Create a value object from a \"literal\".\n"
	"\n"
	"This is used to emulate a literal number in the source code of the\n"
	"program. The type is deduced from *value* according to the language's\n"
	"rules for literals.\n"
	"\n"
	":param value: Value of the literal.\n"
	"\n"
	"Object(prog: Program, type: Union[str, Type], *, address: IntegerLike, bit_offset: IntegerLike = 0, bit_field_size: Optional[IntegerLike] = None)\n"
	"\n"
	"Create a reference object.\n"
	"\n"
	":param address: Address of the object in the program.\n"
	":param bit_offset: Offset in bits from *address* to the beginning of\n"
	"    the object.\n"
	"\n"
	"Object(prog: Program, type: Union[str, Type], *, absence_reason: AbsenceReason = AbsenceReason.OTHER, bit_field_size: Optional[IntegerLike] = None)\n"
	"\n"
	"Create an absent object.";
const char drgn_Object___new___DOC[] =
	"__new__(prog: _drgn.Program, type: Union[str, _drgn.Type], value: Union[_drgn.IntegerLike, float, bool, Mapping[str, Any], Sequence[Any]], *, bit_field_size: Optional[_drgn.IntegerLike] = None) -> Self\n"
	"\n"
	"Create a value object given its type and value.\n"
	"\n"
	":param prog: Program to create the object in.\n"
	":param type: Type of the object.\n"
	":param value: Value of the object. See :meth:`value_()`.\n"
	":param bit_field_size: Size in bits of the object if it is a bit field.\n"
	"    The default is ``None``, which means the object is not a bit field.\n"
	"\n"
	"__new__(prog: _drgn.Program, *, value: Union[int, float, bool]) -> Self\n"
	"\n"
	"Create a value object from a \"literal\".\n"
	"\n"
	"This is used to emulate a literal number in the source code of the\n"
	"program. The type is deduced from *value* according to the language's\n"
	"rules for literals.\n"
	"\n"
	":param value: Value of the literal.\n"
	"\n"
	"__new__(prog: _drgn.Program, type: Union[str, _drgn.Type], *, address: _drgn.IntegerLike, bit_offset: _drgn.IntegerLike = 0, bit_field_size: Optional[_drgn.IntegerLike] = None) -> Self\n"
	"\n"
	"Create a reference object.\n"
	"\n"
	":param address: Address of the object in the program.\n"
	":param bit_offset: Offset in bits from *address* to the beginning of\n"
	"    the object.\n"
	"\n"
	"__new__(prog: _drgn.Program, type: Union[str, _drgn.Type], *, absence_reason: _drgn.AbsenceReason = _drgn.AbsenceReason.OTHER, bit_field_size: Optional[_drgn.IntegerLike] = None) -> Self\n"
	"\n"
	"Create an absent object.";
const char drgn_Object_prog__DOC[] =
	"Final[_drgn.Program]\n"
	"\n"
	"Program that this object is from.";
const char drgn_Object_type__DOC[] =
	"Final[_drgn.Type]\n"
	"\n"
	"Type of this object.";
const char drgn_Object_address__DOC[] =
	"Final[Optional[int]]\n"
	"\n"
	"Address of this object if it is a reference, ``None`` if it is a value or\n"
	"absent.";
const char drgn_Object_absent__DOC[] =
	"Final[bool]\n"
	"\n"
	"Whether this object is absent.\n"
	"\n"
	"This is ``False`` for all values and references (even if the reference has\n"
	"an invalid address).";
const char drgn_Object_absence_reason__DOC[] =
	"Final[Optional[_drgn.AbsenceReason]]\n"
	"\n"
	"Reason that this object is absent.\n"
	"\n"
	"This is ``None`` for all values and references.";
const char drgn_Object_bit_offset__DOC[] =
	"Final[Optional[int]]\n"
	"\n"
	"Offset in bits from this object's address to the beginning of the object if\n"
	"it is a reference, ``None`` otherwise. This can only be non-zero for\n"
	"scalars.";
const char drgn_Object_bit_field_size__DOC[] =
	"Final[Optional[int]]\n"
	"\n"
	"Size in bits of this object if it is a bit field, ``None`` if it is not.";
const char drgn_Object___getattr___DOC[] =
	"__getattr__(name: str) -> _drgn.Object\n"
	"\n"
	"Implement ``self.name``.\n"
	"\n"
	"This corresponds to both the member access (``.``) and member access\n"
	"through pointer (``->``) operators in C.\n"
	"\n"
	"Note that if *name* is an attribute or method of the :class:`Object`\n"
	"class, then that takes precedence. Otherwise, this is equivalent to\n"
	":meth:`member_()`.\n"
	"\n"
	">>> print(prog['init_task'].pid)\n"
	"(pid_t)0\n"
	"\n"
	":param name: Attribute name.";
const char drgn_Object___getitem___DOC[] =
	"__getitem__(i: _drgn.IntegerLike) -> _drgn.Object\n"
	"\n"
	"Implement ``self[i]``. Get the array element at the given index.\n"
	"\n"
	"This is only valid for pointers and arrays.\n"
	"\n"
	">>> print(prog[\"init_task\"].comm[1])\n"
	"(char)119\n"
	"\n"
	"``[0]`` is also the equivalent of the pointer dereference (``*``)\n"
	"operator in C:\n"
	"\n"
	">>> ptr_to_ptr\n"
	"*(void **)0xffff9b86801e2968 = 0xffff9b86801e2460\n"
	">>> print(ptr_to_ptr[0])\n"
	"(void *)0xffff9b86801e2460\n"
	"\n"
	".. note::\n"
	"\n"
	"    Negative indices are relative to the start of the pointer/array\n"
	"    (like in C), not relative to the end (like for Python lists).\n"
	"\n"
	"    >>> ptr[-2].address_of_() == ptr - 2\n"
	"    True\n"
	"\n"
	":param i: Index.\n"
	":raises TypeError: if this object is not a pointer or array\n"
	"\n"
	"__getitem__(s: slice) -> _drgn.Object\n"
	"\n"
	"Implement ``self[start:stop]``. Get an array :term:`slice`.\n"
	"\n"
	"This is only valid for pointers and arrays. It creates a new array for\n"
	"the range of elements from the (inclusive) start index to the\n"
	"(exclusive) stop index. The length of the resulting array is therefore\n"
	"the stop index minus the start index, or zero if the stop index is less\n"
	"than the start index.\n"
	"\n"
	"If the start index is omitted, it defaults to 0. If the stop index is\n"
	"omitted, it defaults to the length of the array (in which case the\n"
	"object must be a complete array).\n"
	"\n"
	"For example, this can be used to get a subset of an array:\n"
	"\n"
	">>> prog[\"init_task\"].comm[1:3]\n"
	"(char [2])\"wa\"\n"
	"\n"
	"Or to get a complete array from a pointer/incomplete array with a\n"
	"separate length:\n"
	"\n"
	">>> poll_list\n"
	"*(struct poll_list *)0xffffa3d3c126fa70 = {\n"
	"        .next = (struct poll_list *)0x0,\n"
	"        .len = (unsigned int)2,\n"
	"        .entries = (struct pollfd []){},\n"
	"}\n"
	">>> poll_list.entries[:poll_list.len]\n"
	"(struct pollfd [2]){\n"
	"        {\n"
	"                .fd = (int)6,\n"
	"                .events = (short)1,\n"
	"                .revents = (short)0,\n"
	"        },\n"
	"        {\n"
	"                .fd = (int)14,\n"
	"                .events = (short)1,\n"
	"                .revents = (short)0,\n"
	"        },\n"
	"}\n"
	"\n"
	".. note::\n"
	"\n"
	"    Negative indices are relative to the start of the pointer/array\n"
	"    (like in C), not relative to the end (like for Python lists).\n"
	"\n"
	"    >>> prog['init_task'].comm[-2:]\n"
	"    (char [18])\"\"\n"
	"    >>> prog['init_task'].comm[:-2]\n"
	"    (char [0]){}\n"
	"\n"
	":param s: Slice.\n"
	":raises TypeError: if this object is not a pointer or array\n"
	":raises TypeError: if the stop index is omitted and this object is not\n"
	"    an array with complete type";
const char drgn_Object___len___DOC[] =
	"__len__() -> int\n"
	"\n"
	"Implement ``len(self)``. Get the number of elements in this object.\n"
	"\n"
	">>> len(prog[\"init_task\"].comm)\n"
	"16\n"
	"\n"
	"This is only valid for arrays.\n"
	"\n"
	":raises TypeError: if this object is not an array with complete type";
const char drgn_Object_value__DOC[] =
	"value_() -> Any\n"
	"\n"
	"Get the value of this object as a Python object.\n"
	"\n"
	"For basic types (integer, floating-point, boolean), this returns an\n"
	"object of the directly corresponding Python type (``int``, ``float``,\n"
	"``bool``). For pointers, this returns the address value of the pointer.\n"
	"For enums, this returns an ``int``. For structures and unions, this\n"
	"returns a ``dict`` of members. For arrays, this returns a ``list`` of\n"
	"values.\n"
	"\n"
	".. note::\n"
	"    Helpers that wish to accept an argument that may be an\n"
	"    :class:`Object` or an :class:`int` should use\n"
	"    :func:`operator.index()` and :class:`IntegerLike` instead:\n"
	"\n"
	"    .. code-block:: python3\n"
	"\n"
	"        import operator\n"
	"        from drgn import IntegerLike\n"
	"\n"
	"        def my_helper(i: IntegerLike) -> ...:\n"
	"            value = operator.index(i)  # Returns an int\n"
	"            ...\n"
	"\n"
	":raises FaultError: if reading the object causes a bad memory access\n"
	":raises TypeError: if this object has an unreadable type (e.g.,\n"
	"    ``void``)";
const char drgn_Object_string__DOC[] =
	"string_() -> bytes\n"
	"\n"
	"Read a null-terminated string pointed to by this object.\n"
	"\n"
	"This is only valid for pointers and arrays. The element type is\n"
	"ignored; this operates byte-by-byte.\n"
	"\n"
	"For pointers and flexible arrays, this stops at the first null byte.\n"
	"\n"
	"For complete arrays, this stops at the first null byte or at the end of\n"
	"the array.\n"
	"\n"
	":raises FaultError: if reading the string causes a bad memory access\n"
	":raises TypeError: if this object is not a pointer or array";
const char drgn_Object_member__DOC[] =
	"member_(name: str) -> _drgn.Object\n"
	"\n"
	"Get a member of this object.\n"
	"\n"
	"This is valid for structures, unions, classes, and pointers to any of\n"
	"those. If the object is a pointer, it is automatically dereferenced\n"
	"first.\n"
	"\n"
	"Normally the dot operator (:meth:`. <__getattr__>`) can be used to\n"
	"accomplish the same thing, but this method can be used if there is a\n"
	"name conflict with an ``Object`` attribute or method.\n"
	"\n"
	":param name: Name of the member.\n"
	":raises TypeError: if this object is not a structure, union, class, or\n"
	"    a pointer to one of those\n"
	":raises LookupError: if this object does not have a member with the\n"
	"    given name";
const char drgn_Object_subobject__DOC[] =
	"subobject_(designator: str) -> _drgn.Object\n"
	"\n"
	"Get a subobject (member or element) of this object.\n"
	"\n"
	"Usually, a combination of the :meth:`. <__getattr__>` and :meth:`[]\n"
	"<.__getitem__>` operators can be used instead, but this can be used as:\n"
	"\n"
	"1. A variant of :meth:`member_()` that doesn't automatically\n"
	"   dereference pointers.\n"
	"2. A generalization of :func:`offsetof()`.\n"
	"\n"
	">>> prog[\"init_task\"].subobject_(\"comm[0]\") == prog[\"init_task\"].comm[0]\n"
	"True\n"
	"\n"
	":param designator: One or more member references or array subscripts.";
const char drgn_Object_address_of__DOC[] =
	"address_of_() -> _drgn.Object\n"
	"\n"
	"Get a pointer to this object.\n"
	"\n"
	"This corresponds to the address-of (``&``) operator in C. It is only\n"
	"possible for reference objects, as value objects don't have an address\n"
	"in the program.\n"
	"\n"
	"As opposed to :attr:`address_`, this returns an ``Object``, not an\n"
	"``int``.\n"
	"\n"
	":raises ValueError: if this object is a value";
const char drgn_Object_read__DOC[] =
	"read_() -> _drgn.Object\n"
	"\n"
	"Read this object (which may be a reference or a value) and return it as\n"
	"a value object.\n"
	"\n"
	"This is useful if the object can change in the running program (but of\n"
	"course nothing stops the program from modifying the object while it is\n"
	"being read).\n"
	"\n"
	"As opposed to :meth:`value_()`, this returns an ``Object``, not a\n"
	"standard Python type.\n"
	"\n"
	":raises FaultError: if reading this object causes a bad memory access\n"
	":raises TypeError: if this object has an unreadable type (e.g.,\n"
	"    ``void``)";
const char drgn_Object_to_bytes__DOC[] =
	"to_bytes_() -> bytes\n"
	"\n"
	"Return the binary representation of this object's value.";
const char drgn_Object_from_bytes__DOC[] =
	"from_bytes_(prog: _drgn.Program, type: Union[str, _drgn.Type], bytes: collections.abc.Buffer, *, bit_offset: _drgn.IntegerLike = 0, bit_field_size: Optional[_drgn.IntegerLike] = None) -> _drgn.Object\n"
	"\n"
	"Return a value object from its binary representation.\n"
	"\n"
	">>> print(Object.from_bytes_(prog, \"int\", b\"\\x10\\x00\\x00\\x00\"))\n"
	"(int)16\n"
	"\n"
	":param prog: Program to create the object in.\n"
	":param type: Type of the object.\n"
	":param bytes: Buffer containing value of the object.\n"
	":param bit_offset: Offset in bits from the beginning of *bytes* to the\n"
	"    beginning of the object.\n"
	":param bit_field_size: Size in bits of the object if it is a bit field.\n"
	"    The default is ``None``, which means the object is not a bit field.";
const char drgn_Object_format__DOC[] =
	"format_(*, columns: Optional[_drgn.IntegerLike] = None, integer_base: Optional[_drgn.IntegerLike] = None, dereference: Optional[bool] = None, symbolize: Optional[bool] = None, string: Optional[bool] = None, char: Optional[bool] = None, type_name: Optional[bool] = None, member_type_names: Optional[bool] = None, element_type_names: Optional[bool] = None, members_same_line: Optional[bool] = None, elements_same_line: Optional[bool] = None, member_names: Optional[bool] = None, element_indices: Optional[bool] = None, implicit_members: Optional[bool] = None, implicit_elements: Optional[bool] = None) -> str\n"
	"\n"
	"Format this object in programming language syntax.\n"
	"\n"
	"Various format options can be passed (as keyword arguments) to control\n"
	"the output. Options that aren't passed or are passed as ``None`` fall\n"
	"back to a default. Specifically, ``obj.format_()`` (i.e., with no\n"
	"passed options) is equivalent to ``str(obj)``.\n"
	"\n"
	">>> workqueues = prog['workqueues']\n"
	">>> print(workqueues)\n"
	"(struct list_head){\n"
	"        .next = (struct list_head *)0xffff932ecfc0ae10,\n"
	"        .prev = (struct list_head *)0xffff932e3818fc10,\n"
	"}\n"
	">>> print(workqueues.format_(type_name=False,\n"
	"...                          member_type_names=False,\n"
	"...                          member_names=False,\n"
	"...                          members_same_line=True))\n"
	"{ 0xffff932ecfc0ae10, 0xffff932e3818fc10 }\n"
	"\n"
	":param columns: Number of columns to limit output to when the\n"
	"    expression can be reasonably wrapped. Defaults to no limit.\n"
	":param integer_base: Base to format integers in (8, 10, or 16).\n"
	"    Defaults to 10.\n"
	":param dereference: If this object is a pointer, include the\n"
	"    dereferenced value. This does not apply to structure, union, or\n"
	"    class members, or array elements, as dereferencing those could lead\n"
	"    to an infinite loop. Defaults to ``True``.\n"
	":param symbolize: Include a symbol name and offset for pointer objects.\n"
	"    Defaults to ``True``.\n"
	":param string: Format the values of objects with string type as strings.\n"
	"    For C, this applies to pointers to and arrays of ``char``, ``signed\n"
	"    char``, and ``unsigned char``. Defaults to ``True``.\n"
	":param char: Format objects with character type as character literals.\n"
	"    For C, this applies to ``char``, ``signed char``, and ``unsigned\n"
	"    char``. Defaults to ``False``.\n"
	":param type_name: Include the type name of this object. Defaults to\n"
	"    ``True``.\n"
	":param member_type_names: Include the type names of structure, union,\n"
	"    and class members. Defaults to ``True``.\n"
	":param element_type_names: Include the type names of array elements.\n"
	"    Defaults to ``False``.\n"
	":param members_same_line: Place multiple structure, union, and class\n"
	"    members on the same line if they fit within the specified\n"
	"    number of ``columns``. Defaults to ``False``.\n"
	":param elements_same_line: Place multiple array elements on the same\n"
	"    line if they fit within the specified number of ``columns``.\n"
	"    Defaults to ``True``.\n"
	":param member_names: Include the names of structure, union, and class\n"
	"    members. Defaults to ``True``.\n"
	":param element_indices: Include the indices of array elements. Defaults\n"
	"    to ``False``.\n"
	":param implicit_members: Include structure, union, and class members\n"
	"    which have an implicit value (i.e., for C, zero-initialized).\n"
	"    Defaults to ``True``.\n"
	":param implicit_elements: Include array elements which have an implicit\n"
	"    value (i.e., for C, zero-initialized). Defaults to ``False``.";
const char drgn_AbsenceReason_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"Reason an object is :ref:absent <absent-objects>`.";
const char drgn_AbsenceReason_OTHER_DOC[] =
	"Another reason not listed below.";
const char drgn_AbsenceReason_OPTIMIZED_OUT_DOC[] =
	"Object was optimized out by the compiler.";
const char drgn_AbsenceReason_NOT_IMPLEMENTED_DOC[] =
	"Encountered unknown debugging information.";
const char drgn_NULL_DOC[] =
	"NULL(prog: Program, type: Union[str, Type]) -> Object\n"
	"\n"
	"Get an object representing ``NULL`` casted to the given type.\n"
	"\n"
	"This is equivalent to ``Object(prog, type, 0)``.\n"
	"\n"
	":param prog: The program.\n"
	":param type: The type.";
const char drgn_cast_DOC[] =
	"cast(type: Union[str, Type], obj: Object) -> Object\n"
	"\n"
	"Get the value of an object explicitly casted to another type.\n"
	"\n"
	"This uses the programming language's rules for explicit conversions, like\n"
	"the cast operator.\n"
	"\n"
	">>> cast(\"unsigned int\", Object(prog, \"float\", 2.0))\n"
	"(unsigned int)2\n"
	">>> cast(\"void *\", Object(prog, \"int\", 0))\n"
	"(void *)0x0\n"
	"\n"
	"See also :func:`implicit_convert()` for implicit conversions (which usually\n"
	"do stricter type checking) and :func:`reinterpret()` for reinterpreting the\n"
	"raw memory of an object.\n"
	"\n"
	":param type: Type to cast to.\n"
	":param obj: Object to cast.\n"
	":return: Casted object. This is always a value object.\n"
	":raises TypeError: if casting *obj* to *type* is not allowed";
const char drgn_implicit_convert_DOC[] =
	"implicit_convert(type: Union[str, Type], obj: Object, *, bit_field_size: Optional[IntegerLike] = None) -> Object\n"
	"\n"
	"Get the value of an object implicitly converted to another type.\n"
	"\n"
	"This uses the programming language's rules for implicit conversions, like\n"
	"when assigning to a variable or passing arguments to a function call.\n"
	"\n"
	">>> implicit_convert(\"unsigned int\", Object(prog, \"float\", 2.0))\n"
	"(unsigned int)2\n"
	">>> implicit_convert(\"void *\", Object(prog, \"int\", 0))\n"
	"Traceback (most recent call last):\n"
	"  ...\n"
	"TypeError: cannot convert 'int' to incompatible type 'void *'\n"
	"\n"
	"See also :func:`cast()` for explicit conversions and :func:`reinterpret()`\n"
	"for reinterpreting the raw memory of an object.\n"
	"\n"
	":param type: Type to convert to.\n"
	":param obj: Object to convert.\n"
	":param bit_field_size: Size in bits if converting to a bit field.\n"
	"    The default is ``None``, which means the result is not a bit field.\n"
	":return: Converted object. This is always a value object.\n"
	":raises TypeError: if converting *obj* to *type* is not allowed";
const char drgn_reinterpret_DOC[] =
	"reinterpret(type: Union[str, Type], obj: Object) -> Object\n"
	"\n"
	"Get the representation of an object reinterpreted as another type.\n"
	"\n"
	"This reinterprets the raw memory of the object, so an object can be\n"
	"reinterpreted as any other type.\n"
	"\n"
	">>> reinterpret(\"unsigned int\", Object(prog, \"float\", 2.0))\n"
	"(unsigned int)1073741824\n"
	"\n"
	".. note::\n"
	"\n"
	"    You usually want :func:`cast()` or :func:`implicit_convert()` instead,\n"
	"    which convert the *value* of an object instead of its in-memory\n"
	"    representation.\n"
	"\n"
	":param type: Type to reinterpret as.\n"
	":param obj: Object to reinterpret.\n"
	":return: Reinterpreted object. If *obj* is a reference object, then this is\n"
	"    a reference object. If *obj* is a value object, then this is a value\n"
	"    object.\n"
	":raises OutOfBoundsError: if *obj* is a value object and *type* is larger\n"
	"    than *obj*";
const char drgn_container_of_DOC[] =
	"container_of(ptr: Object, type: Union[str, Type], member: str) -> Object\n"
	"\n"
	"Get the containing object of a pointer object.\n"
	"\n"
	"This corresponds to the ``container_of()`` macro in C.\n"
	"\n"
	":param ptr: Pointer to member in containing object.\n"
	":param type: Type of containing object.\n"
	":param member: Name of member in containing object. May include one or more\n"
	"    member references and zero or more array subscripts.\n"
	":return: Pointer to containing object.\n"
	":raises TypeError: if *ptr* is not a pointer or *type* is not a structure,\n"
	"    union, or class type\n"
	":raises ValueError: if the member is not byte-aligned (e.g., because it is\n"
	"    a bit field)\n"
	":raises LookupError: if *type* does not have a member with the given name";
const char drgn_Symbol_DOC[] =
	"A ``Symbol`` represents an entry in the symbol table of a program, i.e., an\n"
	"identifier along with its corresponding address range in the program.\n"
	"\n"
	"Symbol(name: str, address: int, size: int, binding: SymbolBinding, kind: SymbolKind)\n"
	"\n"
	"Create a ``Symbol``.\n"
	"\n"
	":param name: :attr:`Symbol.name`\n"
	":param address: :attr:`Symbol.address`\n"
	":param size: :attr:`Symbol.size`\n"
	":param binding: :attr:`Symbol.binding`\n"
	":param kind: :attr:`Symbol.kind`";
const char drgn_Symbol___new___DOC[] =
	"__new__(name: str, address: int, size: int, binding: _drgn.SymbolBinding, kind: _drgn.SymbolKind) -> Self\n"
	"\n"
	"Create a ``Symbol``.\n"
	"\n"
	":param name: :attr:`Symbol.name`\n"
	":param address: :attr:`Symbol.address`\n"
	":param size: :attr:`Symbol.size`\n"
	":param binding: :attr:`Symbol.binding`\n"
	":param kind: :attr:`Symbol.kind`";
const char drgn_Symbol_name_DOC[] =
	"Final[str]\n"
	"\n"
	"Name of this symbol.";
const char drgn_Symbol_address_DOC[] =
	"Final[int]\n"
	"\n"
	"Start address of this symbol.";
const char drgn_Symbol_size_DOC[] =
	"Final[int]\n"
	"\n"
	"Size of this symbol in bytes.";
const char drgn_Symbol_binding_DOC[] =
	"Final[_drgn.SymbolBinding]\n"
	"\n"
	"Linkage behavior and visibility of this symbol.";
const char drgn_Symbol_kind_DOC[] =
	"Final[_drgn.SymbolKind]\n"
	"\n"
	"Kind of entity represented by this symbol.";
const char drgn_SymbolIndex_DOC[] =
	"A ``SymbolIndex`` contains a static set of symbols and allows efficient\n"
	"lookup by name and address.\n"
	"\n"
	"With :meth:`Program.register_symbol_finder()`, you can add a callback to\n"
	"provide custom symbol finding logic. However, in many cases, all that is\n"
	"necessary is to provide drgn with a list of symbols that you know to be part\n"
	"of the program. This object allows you to do that. It efficiently implements\n"
	"the Symbol Finder API given a static set of symbols. For example::\n"
	"\n"
	"    >>> prog = drgn.Program()\n"
	"    >>> symbol = drgn.Symbol(\"foo\", 0x123, 1, drgn.SymbolBinding.GLOBAL, drgn.SymbolKind.OBJECT)\n"
	"    >>> finder = drgn.SymbolIndex([symbol])\n"
	"    >>> prog.register_symbol_finder(\"SymbolIndex\", finder, enable_index=0)\n"
	"    >>> prog.symbols()\n"
	"    [Symbol(name='foo', address=0x123, size=0x1, binding=<SymbolBinding.GLOBAL: 2>, kind=<SymbolKind.OBJECT: 1>)]\n"
	"    >>> prog.symbol(\"bar\")\n"
	"    Traceback (most recent call last):\n"
	"      File \"<console>\", line 1, in <module>\n"
	"    LookupError: not found\n"
	"    >>> prog.symbol(\"foo\")\n"
	"    Symbol(name='foo', address=0x123, size=0x1, binding=<SymbolBinding.GLOBAL: 2>, kind=<SymbolKind.OBJECT: 1>)\n"
	"    >>> prog.symbol(0x100)\n"
	"    Traceback (most recent call last):\n"
	"      File \"<console>\", line 1, in <module>\n"
	"    LookupError: not found\n"
	"    >>> prog.symbol(0x123)\n"
	"    Symbol(name='foo', address=0x123, size=0x1, binding=<SymbolBinding.GLOBAL: 2>, kind=<SymbolKind.OBJECT: 1>)\n"
	"\n"
	"SymbolIndex(symbols: Iterable[Symbol])\n"
	"\n"
	"Create a ``SymbolIndex`` from a sequence of symbols\n"
	"\n"
	"The returned symbol index satisfies the Symbol Finder API. It supports\n"
	"overlapping symbol address ranges and duplicate symbol names. However,\n"
	"in the case of these sorts of conflicts, it doesn't provide any\n"
	"guarantee on the order of the results, or which result is returned when\n"
	"a single symbol is requested.\n"
	"\n"
	":param symbols: An iterable of symbols\n"
	":returns: A callable object suitable to provide to\n"
	"  :meth:`Program.register_symbol_finder()`.";
const char drgn_SymbolIndex___new___DOC[] =
	"__new__(symbols: Iterable[_drgn.Symbol]) -> Self\n"
	"\n"
	"Create a ``SymbolIndex`` from a sequence of symbols\n"
	"\n"
	"The returned symbol index satisfies the Symbol Finder API. It supports\n"
	"overlapping symbol address ranges and duplicate symbol names. However,\n"
	"in the case of these sorts of conflicts, it doesn't provide any\n"
	"guarantee on the order of the results, or which result is returned when\n"
	"a single symbol is requested.\n"
	"\n"
	":param symbols: An iterable of symbols\n"
	":returns: A callable object suitable to provide to\n"
	"  :meth:`Program.register_symbol_finder()`.";
const char drgn_SymbolIndex___call___DOC[] =
	"__call__(prog: _drgn.Program, name: Optional[str], address: Optional[int], one: bool) -> List[_drgn.Symbol]\n"
	"\n"
	"Lookup symbol by name, address, or both.\n"
	"\n"
	":param prog: (unused) the program looking up this symbol\n"
	":param name: if given, only return symbols with this name\n"
	":param address: if given, only return symbols spanning this address\n"
	":param one: if given, limit the result to a single symbol\n"
	":returns: a list of matching symbols (empty if none are found)";
const char drgn_SymbolBinding_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"A ``SymbolBinding`` describes the linkage behavior and visibility of a\n"
	"symbol.";
const char drgn_SymbolBinding_UNKNOWN_DOC[] =
	"Unknown.";
const char drgn_SymbolBinding_LOCAL_DOC[] =
	"Not visible outside of the object file containing its definition.";
const char drgn_SymbolBinding_GLOBAL_DOC[] =
	"Globally visible.";
const char drgn_SymbolBinding_WEAK_DOC[] =
	"Globally visible but may be overridden by a non-weak global symbol.";
const char drgn_SymbolBinding_UNIQUE_DOC[] =
	"Globally visible even if dynamic shared object is loaded locally. See GCC's\n"
	"``-fno-gnu-unique`` `option\n"
	"<https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html>`_.";
const char drgn_SymbolKind_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"A ``SymbolKind`` describes the kind of entity that a symbol represents.";
const char drgn_SymbolKind_UNKNOWN_DOC[] =
	"Unknown or not defined.";
const char drgn_SymbolKind_OBJECT_DOC[] =
	"Data object (e.g., variable or array).";
const char drgn_SymbolKind_FUNC_DOC[] =
	"Function or other executable code.";
const char drgn_SymbolKind_SECTION_DOC[] =
	"Object file section.";
const char drgn_SymbolKind_FILE_DOC[] =
	"Source file.";
const char drgn_SymbolKind_COMMON_DOC[] =
	"Data object in common block.";
const char drgn_SymbolKind_TLS_DOC[] =
	"Thread-local storage entity.";
const char drgn_SymbolKind_IFUNC_DOC[] =
	"`Indirect function <https://sourceware.org/glibc/wiki/GNU_IFUNC>`_.";
const char drgn_StackTrace_DOC[] =
	"A ``StackTrace`` is a :ref:`sequence <python:typesseq-common>` of\n"
	":class:`StackFrame`.\n"
	"\n"
	"``len(trace)`` is the number of stack frames in the trace. ``trace[0]`` is\n"
	"the innermost stack frame, ``trace[1]`` is its caller, and\n"
	"``trace[len(trace) - 1]`` is the outermost frame. Negative indexing also\n"
	"works: ``trace[-1]`` is the outermost frame and ``trace[-len(trace)]`` is\n"
	"the innermost frame. It is also iterable:\n"
	"\n"
	".. code-block:: python3\n"
	"\n"
	"    for frame in trace:\n"
	"        if frame.name == 'io_schedule':\n"
	"            print('Thread is doing I/O')\n"
	"\n"
	":class:`str() <str>` returns a pretty-printed stack trace:\n"
	"\n"
	">>> prog.stack_trace(1)\n"
	"#0  context_switch (kernel/sched/core.c:4339:2)\n"
	"#1  __schedule (kernel/sched/core.c:5147:8)\n"
	"#2  schedule (kernel/sched/core.c:5226:3)\n"
	"#3  do_wait (kernel/exit.c:1534:4)\n"
	"#4  kernel_wait4 (kernel/exit.c:1678:8)\n"
	"#5  __do_sys_wait4 (kernel/exit.c:1706:13)\n"
	"#6  do_syscall_64 (arch/x86/entry/common.c:47:14)\n"
	"#7  entry_SYSCALL_64+0x7c/0x15b (arch/x86/entry/entry_64.S:112)\n"
	"#8  0x4d49dd\n"
	"\n"
	"The format is subject to change. The drgn CLI is set up so that stack\n"
	"traces are displayed with ``str()`` by default.";
const char drgn_StackTrace_prog_DOC[] =
	"Final[_drgn.Program]\n"
	"\n"
	"Program that this stack trace is from.";
const char drgn_StackFrame_DOC[] =
	"A ``StackFrame`` represents a single *frame* in a thread's call stack.\n"
	"\n"
	":class:`str() <str>` returns a pretty-printed stack frame:\n"
	"\n"
	">>> prog.stack_trace(1)[0]\n"
	"#0 at 0xffffffffb64ac287 (__schedule+0x227/0x606) in context_switch at kernel/sched/core.c:4339:2 (inlined)\n"
	"\n"
	"This includes more information than when printing the full stack trace. The\n"
	"format is subject to change. The drgn CLI is set up so that stack frames\n"
	"are displayed with ``str()`` by default.\n"
	"\n"
	"The :meth:`[] <.__getitem__>` operator can look up function parameters,\n"
	"local variables, and global variables in the scope of the stack frame:\n"
	"\n"
	">>> prog.stack_trace(1)[0]['prev'].pid\n"
	"(pid_t)1\n"
	">>> prog.stack_trace(1)[0]['scheduler_running']\n"
	"(int)1";
const char drgn_StackFrame_name_DOC[] =
	"Final[str]\n"
	"\n"
	"Name of the function or symbol at this frame.\n"
	"\n"
	"This tries to get the best available name for this frame in the following\n"
	"order:\n"
	"\n"
	"1. The name of the function in the source code based on debugging\n"
	"   information (:attr:`frame.function_name <function_name>`).\n"
	"2. The name of the symbol in the binary (:meth:`frame.symbol().name\n"
	"   <symbol>`).\n"
	"3. The program counter in hexadecimal (:attr:`hex(frame.pc) <pc>`).\n"
	"4. The string \"???\".";
const char drgn_StackFrame_function_name_DOC[] =
	"Final[Optional[str]]\n"
	"\n"
	"Name of the function at this frame, or ``None`` if it could not be\n"
	"determined.\n"
	"\n"
	"The name cannot be determined if debugging information is not available for\n"
	"the function, e.g., because it is implemented in assembly.";
const char drgn_StackFrame_is_inline_DOC[] =
	"Final[bool]\n"
	"\n"
	"Whether this frame is for an inlined call.\n"
	"\n"
	"An inline frame shares the same stack frame in memory as its caller.\n"
	"Therefore, it has the same registers (including program counter and thus\n"
	"symbol).";
const char drgn_StackFrame_interrupted_DOC[] =
	"Final[bool]\n"
	"\n"
	"Whether this stack frame was interrupted (for example, by a hardware\n"
	"interrupt, signal, trap, etc.).\n"
	"\n"
	"If this is ``True``, then the register values in this frame are the values\n"
	"at the time that the frame was interrupted.\n"
	"\n"
	"This is ``False`` if the frame is for a function call, in which case the\n"
	"register values are the values when control returns to this frame. In\n"
	"particular, the program counter is the return address, which is typically\n"
	"the instruction after the call instruction.";
const char drgn_StackFrame_pc_DOC[] =
	"Final[int]\n"
	"\n"
	"Program counter at this stack frame.";
const char drgn_StackFrame_sp_DOC[] =
	"Final[int]\n"
	"\n"
	"Stack pointer at this stack frame.";
const char drgn_StackFrame___getitem___DOC[] =
	"__getitem__(name: str) -> _drgn.Object\n"
	"\n"
	"Implement ``self[name]``. Get the object (variable, function parameter,\n"
	"constant, or function) with the given name in the scope of this frame.\n"
	"\n"
	"If the object exists but has been optimized out, this returns an\n"
	":ref:`absent object <absent-objects>`.\n"
	"\n"
	":param name: Object name.";
const char drgn_StackFrame___contains___DOC[] =
	"__contains__(name: str) -> bool\n"
	"\n"
	"Implement ``name in self``. Return whether an object with the given\n"
	"name exists in the scope of this frame.\n"
	"\n"
	":param name: Object name.";
const char drgn_StackFrame_locals_DOC[] =
	"locals() -> List[str]\n"
	"\n"
	"Get a list of the names of all local objects (local variables, function\n"
	"parameters, local constants, and nested functions) in the scope of this\n"
	"frame.\n"
	"\n"
	"Not all names may have present values, but they can be used with the\n"
	":meth:`[] <.__getitem__>` operator to check.";
const char drgn_StackFrame_source_DOC[] =
	"source() -> _drgn.SourceLocation\n"
	"\n"
	"Get the source code location of this frame.\n"
	"\n"
	":raises LookupError: if the source code location is not available";
const char drgn_StackFrame_symbol_DOC[] =
	"symbol() -> _drgn.Symbol\n"
	"\n"
	"Get the function symbol at this stack frame.\n"
	"\n"
	"This is equivalent to:\n"
	"\n"
	".. code-block:: python3\n"
	"\n"
	"    prog.symbol(frame.pc - (0 if frame.interrupted else 1))";
const char drgn_StackFrame_register_DOC[] =
	"register(reg: str) -> int\n"
	"\n"
	"Get the value of the given register at this stack frame.\n"
	"\n"
	":param reg: Register name.\n"
	":raises ValueError: if the register name is not recognized\n"
	":raises LookupError: if the register value is not known";
const char drgn_StackFrame_registers_DOC[] =
	"registers() -> Dict[str, int]\n"
	"\n"
	"Get the values of all available registers at this stack frame as a\n"
	"dictionary with the register names as keys.";
const char drgn_SourceLocation_DOC[] =
	"Bases: NamedTuple\n"
	"\n"
	"File, line, and column location in source code.\n"
	"\n"
	"The attributes can be accessed by name:\n"
	"\n"
	">>> filename = loc.filename\n"
	">>> line = loc.line\n"
	">>> column = loc.column\n"
	"\n"
	"or unpacked:\n"
	"\n"
	">>> filename, line, column = loc\n"
	"\n"
	":class:`str() <str>` returns a pretty-printed location:\n"
	"\n"
	">>> loc\n"
	"context_switch at kernel/sched/core.c:5381:9";
const char drgn_SourceLocation_filename_DOC[] =
	"str\n"
	"\n"
	"Source file name, or empty string if unknown.";
const char drgn_SourceLocation_line_DOC[] =
	"int\n"
	"\n"
	"Source line number, or 0 if unknown.";
const char drgn_SourceLocation_column_DOC[] =
	"int\n"
	"\n"
	"Source column, or 0 if unknown.";
const char drgn_SourceLocation_name_DOC[] =
	"name() -> Optional[str]\n"
	"\n"
	"Get the name of the function or symbol at this source location, or\n"
	"``None`` if it could not be determined.";
const char drgn_SourceLocationList_DOC[] =
	"A :ref:`sequence <python:typesseq-common>` of :class:`SourceLocation`.\n"
	"\n"
	"This is a read-only list of source code locations:\n"
	"\n"
	">>> locs = prog.source_location(0xffffffffb64d70a6)\n"
	">>> print(repr(locs))\n"
	"<_drgn.SourceLocationList object at 0x7fb5d1f8e0e0>\n"
	">>> print(repr(locs[0]))\n"
	"<_drgn.SourceLocation object at 0x7fb5d1feb8d0>\n"
	">>> print(repr(locs[1]))\n"
	"<_drgn.SourceLocation object at 0x7fb5d1feb880>\n"
	"\n"
	"For code address lookups where the address is in an inlined function, the\n"
	"first item corresponds to the innermost inlined function, the second item\n"
	"is its caller, etc.\n"
	"\n"
	":class:`str() <str>` returns a pretty-printed list of locations:\n"
	"\n"
	">>> locs\n"
	"#0  context_switch at kernel/sched/core.c:5381:9\n"
	"#1  __schedule at kernel/sched/core.c:6765:8";
const char drgn_SourceLocationList_prog_DOC[] =
	"Final[_drgn.Program]\n"
	"\n"
	"Program that this source location list is from.";
const char drgn_Type_DOC[] =
	"A ``Type`` object describes a type in a program. Each kind of type (e.g.,\n"
	"integer, structure) has different attributes (e.g., name, size). Types can\n"
	"also have qualifiers (e.g., constant, atomic). Accessing an attribute which\n"
	"does not apply to a type raises an :exc:`AttributeError`.\n"
	"\n"
	":func:`repr()` of a ``Type`` returns a Python representation of the type:\n"
	"\n"
	">>> print(repr(prog.type('sector_t')))\n"
	"prog.typedef_type(name='sector_t', type=prog.int_type(name='unsigned long', size=8, is_signed=False))\n"
	"\n"
	":class:`str() <str>` returns a representation of the type in programming\n"
	"language syntax:\n"
	"\n"
	">>> print(prog.type('sector_t'))\n"
	"typedef unsigned long sector_t\n"
	"\n"
	"The drgn CLI is set up so that types are displayed with ``str()`` instead\n"
	"of ``repr()`` by default.\n"
	"\n"
	"This class cannot be constructed directly. Instead, use one of the\n"
	":ref:`api-type-constructors`.";
const char drgn_Type_prog_DOC[] =
	"Final[_drgn.Program]\n"
	"\n"
	"Program that this type is from.";
const char drgn_Type_kind_DOC[] =
	"Final[_drgn.TypeKind]\n"
	"\n"
	"Kind of this type.";
const char drgn_Type_primitive_DOC[] =
	"Final[Optional[_drgn.PrimitiveType]]\n"
	"\n"
	"If this is a primitive type (e.g., ``int`` or ``double``), the kind of\n"
	"primitive type. Otherwise, ``None``.";
const char drgn_Type_qualifiers_DOC[] =
	"Final[_drgn.Qualifiers]\n"
	"\n"
	"Bitmask of this type's qualifier.";
const char drgn_Type_language_DOC[] =
	"Final[_drgn.Language]\n"
	"\n"
	"Programming language of this type.";
const char drgn_Type_name_DOC[] =
	"Final[str]\n"
	"\n"
	"Name of this type. This is present for integer, boolean, floating-point,\n"
	"and typedef types.";
const char drgn_Type_tag_DOC[] =
	"Final[Optional[str]]\n"
	"\n"
	"Tag of this type, or ``None`` if this is an anonymous type. This is present\n"
	"for structure, union, class, and enumerated types.";
const char drgn_Type_size_DOC[] =
	"Final[Optional[int]]\n"
	"\n"
	"Size of this type in bytes, or ``None`` if this is an incomplete type. This\n"
	"is present for integer, boolean, floating-point, structure, union, class,\n"
	"and pointer types.";
const char drgn_Type_length_DOC[] =
	"Final[Optional[int]]\n"
	"\n"
	"Number of elements in this type, or ``None`` if this is an incomplete type.\n"
	"This is only present for array types.";
const char drgn_Type_is_signed_DOC[] =
	"Final[bool]\n"
	"\n"
	"Whether this type is signed. This is only present for integer types.";
const char drgn_Type_byteorder_DOC[] =
	"Final[str]\n"
	"\n"
	"Byte order of this type: ``'little'`` if it is little-endian, or ``'big'``\n"
	"if it is big-endian. This is present for integer, boolean, floating-point,\n"
	"and pointer types.";
const char drgn_Type_type_DOC[] =
	"Final[_drgn.Type]\n"
	"\n"
	"Type underlying this type, defined as follows:\n"
	"\n"
	"* For typedef types, the aliased type.\n"
	"* For enumerated types, the compatible integer type, which is ``None`` if\n"
	"  this is an incomplete type.\n"
	"* For pointer types, the referenced type.\n"
	"* For array types, the element type.\n"
	"* For function types, the return type.\n"
	"\n"
	"For other types, this attribute is not present.";
const char drgn_Type_members_DOC[] =
	"Final[Optional[Sequence[_drgn.TypeMember]]]\n"
	"\n"
	"List of members of this type, or ``None`` if this is an incomplete type.\n"
	"This is present for structure, union, and class types.";
const char drgn_Type_enumerators_DOC[] =
	"Final[Optional[Sequence[_drgn.TypeEnumerator]]]\n"
	"\n"
	"List of enumeration constants of this type, or ``None`` if this is an\n"
	"incomplete type. This is only present for enumerated types.";
const char drgn_Type_parameters_DOC[] =
	"Final[Sequence[_drgn.TypeParameter]]\n"
	"\n"
	"List of parameters of this type. This is only present for function types.";
const char drgn_Type_is_variadic_DOC[] =
	"Final[bool]\n"
	"\n"
	"Whether this type takes a variable number of arguments. This is only\n"
	"present for function types.";
const char drgn_Type_template_parameters_DOC[] =
	"Final[Sequence[_drgn.TypeTemplateParameter]]\n"
	"\n"
	"List of template parameters of this type. This is present for structure,\n"
	"union, class, and function types.";
const char drgn_Type_type_name_DOC[] =
	"type_name() -> str\n"
	"\n"
	"Get a descriptive full name of this type.";
const char drgn_Type_variable_declaration_DOC[] =
	"variable_declaration(name: str) -> str\n"
	"\n"
	"Format a variable declaration with this type.\n"
	"\n"
	">>> prog.type(\"int [4]\").variable_declaration(\"my_array\")\n"
	"'int my_array[4]'\n"
	"\n"
	":param name: Name of the variable.\n"
	":return: Variable declaration in programming language syntax.";
const char drgn_Type_is_complete_DOC[] =
	"is_complete() -> bool\n"
	"\n"
	"Get whether this type is complete (i.e., the type definition is known).\n"
	"This is always ``False`` for void types. It may be ``False`` for\n"
	"structure, union, class, enumerated, and array types, as well as\n"
	"typedef types where the underlying type is one of those. Otherwise, it\n"
	"is always ``True``.";
const char drgn_Type_qualified_DOC[] =
	"qualified(qualifiers: _drgn.Qualifiers) -> _drgn.Type\n"
	"\n"
	"Get a copy of this type with different qualifiers.\n"
	"\n"
	"Note that the original qualifiers are replaced, not added to.\n"
	"\n"
	":param qualifiers: New type qualifiers.";
const char drgn_Type_unqualified_DOC[] =
	"unqualified() -> _drgn.Type\n"
	"\n"
	"Get a copy of this type with no qualifiers.";
const char drgn_Type_unaliased_DOC[] =
	"unaliased() -> _drgn.Type\n"
	"\n"
	"Get a copy of this type with all top-level typedefs removed.\n"
	"\n"
	"For example, given the following typedefs:\n"
	"\n"
	".. code-block:: c\n"
	"\n"
	"    typedef long long __kernel_loff_t;\n"
	"    typedef __kernel_loff_t loff_t;\n"
	"\n"
	"Then:\n"
	"\n"
	">>> print(prog.type(\"loff_t\").unaliased())\n"
	"long long\n"
	"\n"
	"But in this example:\n"
	"\n"
	".. code-block:: c\n"
	"\n"
	"    typedef loff_t *loffp_t;\n"
	"\n"
	"Only ``loffp_t`` is at the top level, not ``loff_t``:\n"
	"\n"
	">>> print(prog.type(\"loffp_t\").unaliased())\n"
	"loff_t *";
const char drgn_Type_unaliased_kind_DOC[] =
	"unaliased_kind() -> _drgn.TypeKind\n"
	"\n"
	"Get the kind of this type with all typedefs removed.\n"
	"\n"
	"This is a shortcut for :meth:`Type.unaliased().kind <unaliased>`.";
const char drgn_Type_member_DOC[] =
	"member(name: str) -> _drgn.TypeMember\n"
	"\n"
	"Look up a member in this type by name.\n"
	"\n"
	"If this type has any unnamed members, this also matches members of\n"
	"those unnamed members, recursively. If the member is found in an\n"
	"unnamed member, :attr:`TypeMember.bit_offset` and\n"
	":attr:`TypeMember.offset` are adjusted accordingly.\n"
	"\n"
	":param name: Name of the member.\n"
	":raises TypeError: if this type is not a structure, union, or class\n"
	"    type\n"
	":raises LookupError: if this type does not have a member with the given\n"
	"    name";
const char drgn_Type_has_member_DOC[] =
	"has_member(name: str) -> bool\n"
	"\n"
	"Return whether this type has a member with the given name.\n"
	"\n"
	"If this type has any unnamed members, this also matches members of\n"
	"those unnamed members, recursively.\n"
	"\n"
	":param name: Name of the member.\n"
	":raises TypeError: if this type is not a structure, union, or class\n"
	"    type";
const char drgn_TypeMember_DOC[] =
	"A ``TypeMember`` represents a member of a structure, union, or class type.\n"
	"\n"
	"TypeMember(object_or_type: Union[Object, Type, Callable[[], Union[Object, Type]]], name: Optional[str] = None, bit_offset: int = 0)\n"
	"\n"
	"Create a ``TypeMember``.\n"
	"\n"
	":param object_or_type: One of:\n"
	"\n"
	"    1. :attr:`TypeMember.object` as an :class:`Object`.\n"
	"    2. :attr:`TypeMember.type` as a :class:`Type`. In this case,\n"
	"       ``object`` is set to an absent object with that type.\n"
	"    3. A callable that takes no arguments and returns one of the above.\n"
	"       It is called when ``object`` or ``type`` is first accessed, and\n"
	"       the result is cached.\n"
	":param name: :attr:`TypeMember.name`\n"
	":param bit_offset: :attr:`TypeMember.bit_offset`";
const char drgn_TypeMember___new___DOC[] =
	"__new__(object_or_type: Union[_drgn.Object, _drgn.Type, Callable[[], Union[_drgn.Object, _drgn.Type]]], name: Optional[str] = None, bit_offset: int = 0) -> Self\n"
	"\n"
	"Create a ``TypeMember``.\n"
	"\n"
	":param object_or_type: One of:\n"
	"\n"
	"    1. :attr:`TypeMember.object` as an :class:`Object`.\n"
	"    2. :attr:`TypeMember.type` as a :class:`Type`. In this case,\n"
	"       ``object`` is set to an absent object with that type.\n"
	"    3. A callable that takes no arguments and returns one of the above.\n"
	"       It is called when ``object`` or ``type`` is first accessed, and\n"
	"       the result is cached.\n"
	":param name: :attr:`TypeMember.name`\n"
	":param bit_offset: :attr:`TypeMember.bit_offset`";
const char drgn_TypeMember_object_DOC[] =
	"Final[_drgn.Object]\n"
	"\n"
	"Member as an :class:`Object`.\n"
	"\n"
	"This is the default initializer for the member, or an absent object if the\n"
	"member has no default initializer. (However, the DWARF specification as of\n"
	"version 5 does not actually support default member initializers, so this is\n"
	"usually absent.)";
const char drgn_TypeMember_type_DOC[] =
	"Final[_drgn.Type]\n"
	"\n"
	"Member type.\n"
	"\n"
	"This is a shortcut for ``TypeMember.object.type``.";
const char drgn_TypeMember_name_DOC[] =
	"Final[Optional[str]]\n"
	"\n"
	"Member name, or ``None`` if the member is unnamed.";
const char drgn_TypeMember_bit_offset_DOC[] =
	"Final[int]\n"
	"\n"
	"Offset of the member from the beginning of the type in bits.";
const char drgn_TypeMember_offset_DOC[] =
	"Final[int]\n"
	"\n"
	"Offset of the member from the beginning of the type in bytes. If the offset\n"
	"is not byte-aligned, accessing this attribute raises :exc:`ValueError`.";
const char drgn_TypeMember_bit_field_size_DOC[] =
	"Final[Optional[int]]\n"
	"\n"
	"Size in bits of this member if it is a bit field, ``None`` if it is not.\n"
	"\n"
	"This is a shortcut for ``TypeMember.object.bit_field_size_``.";
const char drgn_TypeEnumerator_DOC[] =
	"A ``TypeEnumerator`` represents a constant in an enumerated type.\n"
	"\n"
	"Its name and value may be accessed as attributes or unpacked:\n"
	"\n"
	">>> prog.type('enum pid_type').enumerators[0].name\n"
	"'PIDTYPE_PID'\n"
	">>> name, value = prog.type('enum pid_type').enumerators[0]\n"
	">>> value\n"
	"0\n"
	"\n"
	"TypeEnumerator(name: str, value: int)\n"
	"\n"
	"Create a ``TypeEnumerator``.\n"
	"\n"
	":param name: :attr:`TypeEnumerator.name`\n"
	":param value: :attr:`TypeEnumerator.value`";
const char drgn_TypeEnumerator___new___DOC[] =
	"__new__(name: str, value: int) -> Self\n"
	"\n"
	"Create a ``TypeEnumerator``.\n"
	"\n"
	":param name: :attr:`TypeEnumerator.name`\n"
	":param value: :attr:`TypeEnumerator.value`";
const char drgn_TypeEnumerator_name_DOC[] =
	"Final[str]\n"
	"\n"
	"Enumerator name.";
const char drgn_TypeEnumerator_value_DOC[] =
	"Final[int]\n"
	"\n"
	"Enumerator value.";
const char drgn_TypeParameter_DOC[] =
	"A ``TypeParameter`` represents a parameter of a function type.\n"
	"\n"
	"TypeParameter(default_argument_or_type: Union[Object, Type, Callable[[], Union[Object, Type]]], name: Optional[str] = None)\n"
	"\n"
	"Create a ``TypeParameter``.\n"
	"\n"
	":param default_argument_or_type: One of:\n"
	"\n"
	"    1. :attr:`TypeParameter.default_argument` as an :class:`Object`.\n"
	"    2. :attr:`TypeParameter.type` as a :class:`Type`. In this case,\n"
	"       ``default_argument`` is set to an absent object with that type.\n"
	"    3. A callable that takes no arguments and returns one of the above.\n"
	"       It is called when ``default_argument`` or ``type`` is first\n"
	"       accessed, and the result is cached.\n"
	":param name: :attr:`TypeParameter.name`";
const char drgn_TypeParameter___new___DOC[] =
	"__new__(default_argument_or_type: Union[_drgn.Object, _drgn.Type, Callable[[], Union[_drgn.Object, _drgn.Type]]], name: Optional[str] = None) -> Self\n"
	"\n"
	"Create a ``TypeParameter``.\n"
	"\n"
	":param default_argument_or_type: One of:\n"
	"\n"
	"    1. :attr:`TypeParameter.default_argument` as an :class:`Object`.\n"
	"    2. :attr:`TypeParameter.type` as a :class:`Type`. In this case,\n"
	"       ``default_argument`` is set to an absent object with that type.\n"
	"    3. A callable that takes no arguments and returns one of the above.\n"
	"       It is called when ``default_argument`` or ``type`` is first\n"
	"       accessed, and the result is cached.\n"
	":param name: :attr:`TypeParameter.name`";
const char drgn_TypeParameter_default_argument_DOC[] =
	"Final[_drgn.Object]\n"
	"\n"
	"Default argument for parameter.\n"
	"\n"
	"If the parameter does not have a default argument, then this is an absent\n"
	"object.\n"
	"\n"
	".. note::\n"
	"\n"
	"    Neither GCC nor Clang emits debugging information for default arguments\n"
	"    (as of GCC 10 and Clang 11), and drgn does not yet parse it, so this is\n"
	"    usually absent.";
const char drgn_TypeParameter_type_DOC[] =
	"Final[_drgn.Type]\n"
	"\n"
	"Parameter type.\n"
	"\n"
	"This is the same as ``TypeParameter.default_argument.type_``.";
const char drgn_TypeParameter_name_DOC[] =
	"Final[Optional[str]]\n"
	"\n"
	"Parameter name, or ``None`` if the parameter is unnamed.";
const char drgn_TypeTemplateParameter_DOC[] =
	"A ``TypeTemplateParameter`` represents a template parameter of a structure,\n"
	"union, class, or function type.\n"
	"\n"
	"TypeTemplateParameter(argument: Union[Type, Object, Callable[[], Union[Type, Object]]], name: Optional[str] = None, is_default: bool = False)\n"
	"\n"
	"Create a ``TypeTemplateParameter``.\n"
	"\n"
	":param argument: One of:\n"
	"\n"
	"    1. :attr:`TypeTemplateParameter.argument` as a :class:`Type` if the\n"
	"       parameter is a type template parameter.\n"
	"    2. :attr:`TypeTemplateParameter.argument` as a non-absent\n"
	"       :class:`Object` if the parameter is a non-type template\n"
	"       parameter.\n"
	"    3. A callable that takes no arguments and returns one of the above.\n"
	"       It is called when ``argument`` is first accessed, and the result\n"
	"       is cached.\n"
	":param name: :attr:`TypeTemplateParameter.name`\n"
	":param is_default: :attr:`TypeTemplateParameter.is_default`";
const char drgn_TypeTemplateParameter___new___DOC[] =
	"__new__(argument: Union[_drgn.Type, _drgn.Object, Callable[[], Union[_drgn.Type, _drgn.Object]]], name: Optional[str] = None, is_default: bool = False) -> Self\n"
	"\n"
	"Create a ``TypeTemplateParameter``.\n"
	"\n"
	":param argument: One of:\n"
	"\n"
	"    1. :attr:`TypeTemplateParameter.argument` as a :class:`Type` if the\n"
	"       parameter is a type template parameter.\n"
	"    2. :attr:`TypeTemplateParameter.argument` as a non-absent\n"
	"       :class:`Object` if the parameter is a non-type template\n"
	"       parameter.\n"
	"    3. A callable that takes no arguments and returns one of the above.\n"
	"       It is called when ``argument`` is first accessed, and the result\n"
	"       is cached.\n"
	":param name: :attr:`TypeTemplateParameter.name`\n"
	":param is_default: :attr:`TypeTemplateParameter.is_default`";
const char drgn_TypeTemplateParameter_argument_DOC[] =
	"Final[Union[_drgn.Type, _drgn.Object]]\n"
	"\n"
	"Template argument.\n"
	"\n"
	"If this is a type template parameter, then this is a :class:`Type`. If this\n"
	"is a non-type template parameter, then this is an :class:`Object`.";
const char drgn_TypeTemplateParameter_name_DOC[] =
	"Final[Optional[str]]\n"
	"\n"
	"Template parameter name, or ``None`` if the parameter is unnamed.";
const char drgn_TypeTemplateParameter_is_default_DOC[] =
	"Final[bool]\n"
	"\n"
	"Whether :attr:`argument` is the default for the template parameter.\n"
	"\n"
	".. note::\n"
	"\n"
	"    There are two ways to interpret this:\n"
	"\n"
	"        1. The argument was omitted entirely and thus defaulted to the\n"
	"           default argument.\n"
	"        2. The (specified or defaulted) argument is the same as the default\n"
	"           argument.\n"
	"\n"
	"    Compilers are inconsistent about which interpretation they use.\n"
	"\n"
	"    GCC added this information in version 4.9. Clang added it in version 11\n"
	"    (and only when emitting DWARF version 5). If the program was compiled\n"
	"    by an older version, this is always false.";
const char drgn_TypeKind_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"A ``TypeKind`` represents a kind of type.";
const char drgn_TypeKind_VOID_DOC[] =
	"Void type.";
const char drgn_TypeKind_INT_DOC[] =
	"Integer type.";
const char drgn_TypeKind_BOOL_DOC[] =
	"Boolean type.";
const char drgn_TypeKind_FLOAT_DOC[] =
	"Floating-point type.";
const char drgn_TypeKind_STRUCT_DOC[] =
	"Structure type.";
const char drgn_TypeKind_UNION_DOC[] =
	"Union type.";
const char drgn_TypeKind_CLASS_DOC[] =
	"Class type.";
const char drgn_TypeKind_ENUM_DOC[] =
	"Enumerated type.";
const char drgn_TypeKind_TYPEDEF_DOC[] =
	"Type definition (a.k.a. alias) type.";
const char drgn_TypeKind_POINTER_DOC[] =
	"Pointer type.";
const char drgn_TypeKind_ARRAY_DOC[] =
	"Array type.";
const char drgn_TypeKind_FUNCTION_DOC[] =
	"Function type.";
const char drgn_TypeKindSet_DOC[] =
	"Bases: collections.abc.Set[TypeKind]\n"
	"\n"
	"Immutable set of :class:`TypeKind`\\ s.\n"
	"\n"
	">>> kinds = TypeKindSet({TypeKind.STRUCT, TypeKind.CLASS})\n"
	">>> TypeKind.STRUCT in kinds\n"
	"True\n"
	">>> TypeKind.INT in kinds\n"
	"False\n"
	">>> for kind in kinds:\n"
	"...     print(kind)\n"
	"...\n"
	"TypeKind.STRUCT\n"
	"TypeKind.CLASS";
const char drgn_PrimitiveType_DOC[] =
	"Bases: enum.Enum\n"
	"\n"
	"A ``PrimitiveType`` represents a primitive type known to drgn.";
const char drgn_PrimitiveType_C_VOID_DOC[] = "";
const char drgn_PrimitiveType_C_CHAR_DOC[] = "";
const char drgn_PrimitiveType_C_SIGNED_CHAR_DOC[] = "";
const char drgn_PrimitiveType_C_UNSIGNED_CHAR_DOC[] = "";
const char drgn_PrimitiveType_C_SHORT_DOC[] = "";
const char drgn_PrimitiveType_C_UNSIGNED_SHORT_DOC[] = "";
const char drgn_PrimitiveType_C_INT_DOC[] = "";
const char drgn_PrimitiveType_C_UNSIGNED_INT_DOC[] = "";
const char drgn_PrimitiveType_C_LONG_DOC[] = "";
const char drgn_PrimitiveType_C_UNSIGNED_LONG_DOC[] = "";
const char drgn_PrimitiveType_C_LONG_LONG_DOC[] = "";
const char drgn_PrimitiveType_C_UNSIGNED_LONG_LONG_DOC[] = "";
const char drgn_PrimitiveType_C_BOOL_DOC[] = "";
const char drgn_PrimitiveType_C_FLOAT_DOC[] = "";
const char drgn_PrimitiveType_C_DOUBLE_DOC[] = "";
const char drgn_PrimitiveType_C_LONG_DOUBLE_DOC[] = "";
const char drgn_PrimitiveType_C_SIZE_T_DOC[] = "";
const char drgn_PrimitiveType_C_PTRDIFF_T_DOC[] = "";
const char drgn_Qualifiers_DOC[] =
	"Bases: enum.Flag\n"
	"\n"
	"``Qualifiers`` are modifiers on types.";
const char drgn_Qualifiers_NONE_DOC[] =
	"No qualifiers.";
const char drgn_Qualifiers_CONST_DOC[] =
	"Constant type.";
const char drgn_Qualifiers_VOLATILE_DOC[] =
	"Volatile type.";
const char drgn_Qualifiers_RESTRICT_DOC[] =
	"`Restrict <https://en.cppreference.com/w/c/language/restrict>`_ type.";
const char drgn_Qualifiers_ATOMIC_DOC[] =
	"Atomic type.";
const char drgn_sizeof_DOC[] =
	"sizeof(type_or_obj: Union[Type, Object, str], /) -> int\n"
	"\n"
	"Get the size of a :class:`Type` or :class:`Object` in bytes.\n"
	"\n"
	":param type_or_obj: Entity to get the size of. If given as a string, it is\n"
	"    looked up (first as a type, then as an object) in the\n"
	"    :ref:`default program <default-program>`.\n"
	":raises TypeError: if the type does not have a size (e.g., because it is\n"
	"    incomplete or void)";
const char drgn_alignof_DOC[] =
	"alignof(type: Union[Type, str], /) -> int\n"
	"\n"
	"Get the alignment requirement (in bytes) of a :class:`Type`.\n"
	"\n"
	"This corresponds to |alignof()|_ in C.\n"
	"\n"
	".. |alignof()| replace:: ``_Alignof()``\n"
	".. _alignof(): https://en.cppreference.com/w/c/language/_Alignof\n"
	"\n"
	":param type: Type. If given as a string, it is looked up in the\n"
	"    :ref:`default program <default-program>`.\n"
	":raises TypeError: if *type* is a function type or an incomplete type";
const char drgn_offsetof_DOC[] =
	"offsetof(type: Union[Type, str], member: str) -> int\n"
	"\n"
	"Get the offset (in bytes) of a member in a :class:`Type`.\n"
	"\n"
	"This corresponds to |offsetof()|_ in C.\n"
	"\n"
	".. |offsetof()| replace:: ``offsetof()``\n"
	".. _offsetof(): https://en.cppreference.com/w/c/types/offsetof\n"
	"\n"
	":param type: Structure, union, or class type. If given as a string, it is\n"
	"    looked up in the :ref:`default program <default-program>`.\n"
	":param member: Name of member. May include one or more member references\n"
	"    and zero or more array subscripts.\n"
	":raises TypeError: if *type* is not a structure, union, or class type\n"
	":raises ValueError: if the member is not byte-aligned (e.g., because it is\n"
	"    a bit field)\n"
	":raises LookupError: if *type* does not have a member with the given name";
const char drgn_FaultError_DOC[] =
	"Bases: Exception\n"
	"\n"
	"This error is raised when a bad memory access is attempted (i.e., when\n"
	"accessing a memory address which is not valid in a program).\n"
	"\n"
	"FaultError(message: str, address: int)\n"
	"\n"
	":param message: :attr:`FaultError.message`\n"
	":param address: :attr:`FaultError.address`";
const char drgn_FaultError_message_DOC[] =
	"str\n"
	"\n"
	"Error message.";
const char drgn_FaultError_address_DOC[] =
	"int\n"
	"\n"
	"Address that couldn't be accessed.";
const char drgn_MissingDebugInfoError_DOC[] =
	"Bases: Exception\n"
	"\n"
	"This error is raised when one or more files in a program do not have debug\n"
	"information.";
const char drgn_ObjectAbsentError_DOC[] =
	"Bases: Exception\n"
	"\n"
	"This error is raised when attempting to use an absent object.";
const char drgn_OutOfBoundsError_DOC[] =
	"Bases: Exception\n"
	"\n"
	"This error is raised when attempting to access beyond the bounds of a value\n"
	"object.";
const char drgn__linux_helper_per_cpu_ptr_DOC[] =
	"_linux_helper_per_cpu_ptr(ptr: Object, cpu: IntegerLike) -> Object\n"
	"\n"
	"Return the per-CPU pointer for a given CPU.\n"
	"\n"
	">>> prog[\"init_net\"].loopback_dev.pcpu_refcnt\n"
	"(int *)0x2c980\n"
	">>> per_cpu_ptr(prog[\"init_net\"].loopback_dev.pcpu_refcnt, 7)\n"
	"*(int *)0xffff925e3ddec980 = 4\n"
	"\n"
	":param ptr: Per-CPU pointer, i.e., ``type __percpu *``. For global\n"
	"    variables, it's usually easier to use :func:`per_cpu()`.\n"
	":param cpu: CPU number.\n"
	":return: ``type *`` object.";
const char drgn__linux_helper_task_thread_info_DOC[] =
	"_linux_helper_task_thread_info(task: Object) -> Object\n"
	"\n"
	"Return the thread information structure for a task.\n"
	"\n"
	":param task: ``struct task_struct *``\n"
	":return: ``struct thread_info *``";
const char drgn__linux_helper_task_cpu_DOC[] =
	"_linux_helper_task_cpu(task: Object) -> int\n"
	"\n"
	"Return the CPU number that the given task last ran on.\n"
	"\n"
	":param task: ``struct task_struct *``";
const char drgn__linux_helper_task_on_cpu_DOC[] =
	"_linux_helper_task_on_cpu(task: Object) -> bool\n"
	"\n"
	"Return whether the given task is currently running on a CPU.\n"
	"\n"
	":param task: ``struct task_struct *``";
const char drgn__linux_helper_pid_task_DOC[] =
	"_linux_helper_pid_task(pid: Object, pid_type: IntegerLike) -> Object\n"
	"\n"
	"Return the ``struct task_struct *`` containing the given ``struct pid *``\n"
	"of the given type.\n"
	"\n"
	":param pid: ``struct pid *``\n"
	":param pid_type: ``enum pid_type``\n"
	":return: ``struct task_struct *``";
