// Copyright (c) Meta Platforms, Inc. and affiliates.
// SPDX-License-Identifier: LGPL-2.1-or-later

#include "drgnpy.h"
#include "../bitops.h"
#include "../error.h"
#include "../hash_table.h"
#include "../linux_kernel.h"
#include "../log.h"
#include "../program.h"
#include "../string_builder.h"
#include "../symbol.h"
#include "../util.h"
#include "../vector.h"

DEFINE_HASH_SET_FUNCTIONS(pyobjectp_set, ptr_key_hash_pair, scalar_key_eq);

static PyObject *percent_s;
static PyObject *logging_StreamHandler;
static PyObject *logger;
static PyObject *logger_log;

static void drgnpy_log_fn(struct drgn_program *prog, void *arg,
			  enum drgn_log_level level, const char *format,
			  va_list ap, struct drgn_error *err)
{
	STRING_BUILDER(sb);
	if (!string_builder_vappendf(&sb, format, ap))
		return;
	if (err && !string_builder_append_error(&sb, err))
		return;

	PyGILState_guard();
	PyObject *ret = PyObject_CallFunction(logger_log, "iOs#",
					      (level + 1) * 10, percent_s,
					      sb.str ? sb.str : "",
					      (Py_ssize_t)sb.len);
	if (ret)
		Py_DECREF(ret);
	else
		PyErr_WriteUnraisable(logger_log);
}

static int get_logging_status(int *log_level_ret, bool *enable_progress_bar_ret)
{
	// We don't use getEffectiveLevel() because that doesn't take
	// logging.disable() into account.
	int level;
	for (level = 0; level < DRGN_LOG_NONE; level++) {
		_cleanup_pydecref_ PyObject *enabled =
			PyObject_CallMethod(logger, "isEnabledFor", "i",
					    (level + 1) * 10);
		if (!enabled)
			return -1;
		int ret = PyObject_IsTrue(enabled);
		if (ret < 0)
			return -1;
		if (ret)
			break;
	}

	*log_level_ret = level;

	if (level > DRGN_LOG_WARNING || !isatty(STDERR_FILENO)) {
		*enable_progress_bar_ret = false;
		return 0;
	}

	PyObject *current_logger = logger;
	_cleanup_pydecref_ PyObject *logger_to_decref = NULL;
	do {
		_cleanup_pydecref_ PyObject *handlers =
			PyObject_GetAttrString(current_logger, "handlers");
		if (!handlers)
			return -1;

		Py_ssize_t size = PySequence_Size(handlers);
		if (size < 0)
			return -1;

		for (Py_ssize_t i = 0; i < size; i++) {
			_cleanup_pydecref_ PyObject *handler =
				PySequence_GetItem(handlers, i);
			if (!handler)
				return -1;

			int r = PyObject_IsInstance(handler,
						    logging_StreamHandler);
			if (r < 0)
				return -1;
			if (!r)
				continue;

			_cleanup_pydecref_ PyObject *stream =
				PyObject_GetAttrString(handler, "stream");
			if (!stream)
				return -1;

			_cleanup_pydecref_ PyObject *fd_obj =
				PyObject_CallMethod(stream, "fileno", NULL);
			if (!fd_obj) {
				// Ignore AttributeError,
				// io.UnsupportedOperation, etc.
				if (PyErr_ExceptionMatches(PyExc_Exception)) {
					PyErr_Clear();
					continue;
				} else {
					return -1;
				}
			}

			long fd = PyLong_AsLong(fd_obj);
			if (fd == -1 && PyErr_Occurred())
				return -1;

			if (fd == STDERR_FILENO) {
				*enable_progress_bar_ret = true;
				return 0;
			}
		}

		_cleanup_pydecref_ PyObject *propagate =
			PyObject_GetAttrString(current_logger, "propagate");
		if (!propagate)
			return -1;
		int ret = PyObject_IsTrue(propagate);
		if (ret < 0)
			return -1;
		if (!ret)
			break;

		Py_XDECREF(logger_to_decref);
		logger_to_decref = PyObject_GetAttrString(current_logger,
							  "parent");
		if (!logger_to_decref)
			return -1;
		current_logger = logger_to_decref;
	} while (current_logger != Py_None);

	*enable_progress_bar_ret = false;
	return 0;
}

// This is slightly heinous. We need to sync the Python logging configuration
// with libdrgn, but the Python log level and handlers can change at any time,
// and there are no APIs to be notified of this.
//
// To sync the log level, we monkey patch logger._cache.clear() to update the
// libdrgn log level on every live program.
//
// We also check handlers in that monkey patch, which isn't the right place to
// hook but should work in practice in most cases.
static int cached_log_level;
static bool cached_enable_progress_bar;
static struct pyobjectp_set programs = HASH_TABLE_INIT;

static int cache_logging_status(void)
{
	return get_logging_status(&cached_log_level,
				  &cached_enable_progress_bar);
}

static PyObject *LoggerCacheWrapper_clear(PyObject *self)
{
	PyDict_Clear(self);
	if (!pyobjectp_set_empty(&programs)) {
		if (cache_logging_status())
			return NULL;
		hash_table_for_each(pyobjectp_set, it, &programs) {
			Program *prog = (Program *)*it.entry;
			drgn_program_set_log_level(&prog->prog,
						   cached_log_level);
			drgn_program_set_progress_file(&prog->prog,
						       cached_enable_progress_bar
						       ? stderr : NULL);
		}
	}
	Py_RETURN_NONE;
}

static PyMethodDef LoggerCacheWrapper_methods[] = {
	{"clear", (PyCFunction)LoggerCacheWrapper_clear, METH_NOARGS},
	{},
};

static PyTypeObject LoggerCacheWrapper_type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "_drgn._LoggerCacheWrapper",
	.tp_methods = LoggerCacheWrapper_methods,
};

static int init_logger_cache_wrapper(void)
{
	LoggerCacheWrapper_type.tp_base = &PyDict_Type;
	if (PyType_Ready(&LoggerCacheWrapper_type))
		return -1;
	_cleanup_pydecref_ PyObject *cache_wrapper =
		PyObject_CallFunction((PyObject *)&LoggerCacheWrapper_type,
				      NULL);
	if (!cache_wrapper)
		return -1;
	return PyObject_SetAttrString(logger, "_cache", cache_wrapper);
}

static int Program_init_logging(Program *prog)
{
	// The cache is only maintained while there are live programs, so if
	// this is the only program, we need to update the cache.
	if (pyobjectp_set_empty(&programs) && cache_logging_status())
		return -1;

	PyObject *obj = (PyObject *)prog;
	if (pyobjectp_set_insert(&programs, &obj, NULL) < 0)
		return -1;
	drgn_program_set_log_callback(&prog->prog, drgnpy_log_fn, NULL);
	drgn_program_set_log_level(&prog->prog, cached_log_level);
	drgn_program_set_progress_file(&prog->prog,
				       cached_enable_progress_bar ? stderr : NULL);
	return 0;
}

static void Program_deinit_logging(Program *prog)
{
	PyObject *obj = (PyObject *)prog;
	pyobjectp_set_delete(&programs, &obj);
}

int init_logging(void)
{
	percent_s = PyUnicode_InternFromString("%s");
	if (!percent_s)
		return -1;

	_cleanup_pydecref_ PyObject *logging = PyImport_ImportModule("logging");
	if (!logging)
		return -1;
	logging_StreamHandler = PyObject_GetAttrString(logging,
						       "StreamHandler");
	if (!logging_StreamHandler)
		return -1;
	logger = PyObject_CallMethod(logging, "getLogger", "s", "drgn");
	if (!logger)
		return -1;
	logger_log = PyObject_GetAttrString(logger, "log");
	if (!logger_log)
		return -1;

	return init_logger_cache_wrapper();
}

int Program_hold_object(Program *prog, PyObject *obj)
{
	int ret = pyobjectp_set_insert(&prog->objects, &obj, NULL);
	if (ret > 0) {
		Py_INCREF(obj);
		ret = 0;
	} else if (ret < 0) {
		PyErr_NoMemory();
	}
	return ret;
}

bool Program_hold_reserve(Program *prog, size_t n)
{
	if (!pyobjectp_set_reserve(&prog->objects,
				   pyobjectp_set_size(&prog->objects) + n)) {
		PyErr_NoMemory();
		return false;
	}
	return true;
}

int Program_type_arg(Program *prog, PyObject *type_obj, bool can_be_none,
		     struct drgn_qualified_type *ret)
{
	struct drgn_error *err;

	if (PyObject_TypeCheck(type_obj, &DrgnType_type)) {
		if (DrgnType_prog((DrgnType *)type_obj) != prog) {
			PyErr_SetString(PyExc_ValueError,
					"type is from different program");
			return -1;
		}
		ret->type = ((DrgnType *)type_obj)->type;
		ret->qualifiers = ((DrgnType *)type_obj)->qualifiers;
	} else if (PyUnicode_Check(type_obj)) {
		const char *name;

		name = PyUnicode_AsUTF8(type_obj);
		if (!name)
			return -1;
		err = drgn_program_find_type(&prog->prog, name, NULL, ret);
		if (err) {
			set_drgn_error(err);
			return -1;
		}
	} else if (can_be_none && type_obj == Py_None) {
		ret->type = NULL;
		ret->qualifiers = 0;
	} else {
		PyErr_SetString(PyExc_TypeError,
				can_be_none ?
				"type must be Type, str, or None" :
				"type must be Type or str");
		return -1;
	}
	return 0;
}

drgn_blocking_state drgn_begin_blocking(void)
{
	PyThreadState *state = PyGILState_GetThisThreadState();
	// If the current thread doesn't hold the GIL (because it's not in
	// Python or because this blocking section is nested in another), don't
	// do anything.
	if (!state || state != PyThreadState_GetUnchecked())
		return NULL;
	PyEval_ReleaseThread(state);
	return (drgn_blocking_state)state;
}

void drgn_end_blocking(drgn_blocking_state state)
{
	if (state)
		PyEval_RestoreThread((PyThreadState *)state);
}

static Program *Program_new_impl(const struct drgn_platform *platform)
{
	_cleanup_pydecref_ PyObject *cache = PyDict_New();
	if (!cache)
		return NULL;
	_cleanup_pydecref_ PyObject *config = PyDict_New();
	if (!config)
		return NULL;

	_cleanup_pydecref_ Program *prog = call_tp_alloc(Program);
	if (!prog)
		return NULL;
	prog->cache = no_cleanup_ptr(cache);
	prog->config = no_cleanup_ptr(config);
	pyobjectp_set_init(&prog->objects);
	drgn_program_init(&prog->prog, platform);
	if (Program_init_logging(prog))
		return NULL;
	return_ptr(prog);
}

static Program *Program_new(PyTypeObject *subtype, PyObject *args,
			    PyObject *kwds)
{
	static char *keywords[] = { "platform", "vmcoreinfo", NULL };
	PyObject *platform_obj = NULL;
	const char *vmcoreinfo = NULL;
	Py_ssize_t vmcoreinfo_size;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O$z#:Program", keywords,
					 &platform_obj, &vmcoreinfo,
					 &vmcoreinfo_size))
		return NULL;

	struct drgn_platform *platform;
	if (!platform_obj || platform_obj == Py_None) {
		platform = NULL;
	} else if (PyObject_TypeCheck(platform_obj, &Platform_type)) {
		platform = ((Platform *)platform_obj)->platform;
	} else {
		PyErr_SetString(PyExc_TypeError,
				"platform must be Platform or None");
		return NULL;
	}
	_cleanup_pydecref_ Program *prog = Program_new_impl(platform);
	if (!prog)
		return NULL;
	if (vmcoreinfo) {
		struct drgn_error *err = drgn_program_parse_vmcoreinfo(
			&prog->prog, vmcoreinfo, vmcoreinfo_size);
		if (err)
			return set_drgn_error(err);
	}
	return_ptr(prog);
}

LIBDRGN_PUBLIC struct drgn_error *
drgn_program_create(const struct drgn_platform *platform,
		    struct drgn_program **ret)
{
	bool success;
	drgn_initialize_python_guard(&success);
	if (!success)
		return drgn_error_from_python();
	Program *prog = Program_new_impl(platform);
	if (!prog)
		return drgn_error_from_python();
	*ret = &prog->prog;
	return NULL;
}

LIBDRGN_PUBLIC void drgn_program_destroy(struct drgn_program *prog)
{
	if (prog) {
		PyGILState_guard();
		Py_DECREF(container_of(prog, Program, prog));
	}
}

static void Program_dealloc(Program *self)
{
	PyObject_GC_UnTrack(self);
	Program_deinit_logging(self);
	drgn_program_deinit(&self->prog);
	hash_table_for_each(pyobjectp_set, it, &self->objects)
		Py_DECREF(*it.entry);
	pyobjectp_set_deinit(&self->objects);
	Py_XDECREF(self->config);
	Py_XDECREF(self->cache);
	Py_TYPE(self)->tp_free((PyObject *)self);
}

static int Program_traverse(Program *self, visitproc visit, void *arg)
{
	hash_table_for_each(pyobjectp_set, it, &self->objects)
		Py_VISIT(*it.entry);
	Py_VISIT(self->cache);
	Py_VISIT(self->config);
	return 0;
}

static int Program_clear(Program *self)
{
	hash_table_for_each(pyobjectp_set, it, &self->objects)
		Py_DECREF(*it.entry);
	pyobjectp_set_deinit(&self->objects);
	pyobjectp_set_init(&self->objects);
	Py_CLEAR(self->cache);
	Py_CLEAR(self->config);
	return 0;
}

static struct drgn_error *py_memory_read_fn(void *buf, uint64_t address,
					    size_t count, uint64_t offset,
					    void *arg, bool physical)
{
	struct drgn_error *err;

	PyGILState_guard();

	_cleanup_pydecref_ PyObject *ret =
		PyObject_CallFunction(arg, "KKKO", (unsigned long long)address,
				      (unsigned long long)count,
				      (unsigned long long)offset,
				      physical ? Py_True : Py_False);
	if (!ret)
		return drgn_error_from_python();
	Py_buffer view;
	if (PyObject_GetBuffer(ret, &view, PyBUF_SIMPLE) == -1)
		return drgn_error_from_python();
	if (view.len != count) {
		PyErr_Format(PyExc_ValueError,
			     "memory read callback returned buffer of length %zd (expected %zu)",
			     view.len, count);
		err = drgn_error_from_python();
		goto out;
	}
	memcpy(buf, view.buf, count);
	err = NULL;
out:
	PyBuffer_Release(&view);
	return err;
}

static PyObject *Program_add_memory_segment(Program *self, PyObject *args,
					    PyObject *kwds)
{
	static char *keywords[] = {
		"address", "size", "read_fn", "physical", NULL,
	};
	struct drgn_error *err;
	struct index_arg address = {};
	struct index_arg size = {};
	PyObject *read_fn;
	int physical = 0;

	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					 "O&O&O|p:add_memory_segment", keywords,
					 index_converter, &address,
					 index_converter, &size, &read_fn,
					 &physical))
	    return NULL;

	if (!PyCallable_Check(read_fn)) {
		PyErr_SetString(PyExc_TypeError, "read_fn must be callable");
		return NULL;
	}

	if (Program_hold_object(self, read_fn) == -1)
		return NULL;
	err = drgn_program_add_memory_segment(&self->prog, address.uvalue,
					      size.uvalue, py_memory_read_fn,
					      read_fn, physical);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static struct drgn_error *
py_debug_info_find_fn(struct drgn_module * const *modules, size_t num_modules,
		      void *arg)
{
	PyGILState_guard();

	_cleanup_pydecref_ PyObject *modules_list = PyList_New(num_modules);
	if (!modules_list)
		return drgn_error_from_python();
	for (size_t i = 0; i < num_modules; i++) {
		PyObject *module_obj = Module_wrap(modules[i]);
		if (!module_obj)
			return drgn_error_from_python();
		PyList_SET_ITEM(modules_list, i, module_obj);
	}
	_cleanup_pydecref_ PyObject *obj =
		PyObject_CallOneArg(arg, modules_list);
	if (!obj)
		return drgn_error_from_python();
	return NULL;
}

static inline struct drgn_error *
py_type_find_fn_common(PyObject *type_obj, void *arg,
		       struct drgn_qualified_type *ret)
{
	if (!PyObject_TypeCheck(type_obj, &DrgnType_type)) {
		PyErr_SetString(PyExc_TypeError,
				"type find callback must return Type or None");
		return drgn_error_from_python();
	}
	// This check is also done in libdrgn, but we need it here because if
	// the type isn't from this program, then there's no guarantee that it
	// will remain valid after we decrement its reference count.
	if (DrgnType_prog((DrgnType *)type_obj)
	    != (Program *)PyTuple_GET_ITEM(arg, 0)) {
		PyErr_SetString(PyExc_ValueError,
				"type find callback returned type from wrong program");
		return drgn_error_from_python();
	}
	ret->type = ((DrgnType *)type_obj)->type;
	ret->qualifiers = ((DrgnType *)type_obj)->qualifiers;
	return NULL;
}

static struct drgn_error *py_type_find_fn(uint64_t kinds, const char *name,
					  size_t name_len, const char *filename,
					  void *arg,
					  struct drgn_qualified_type *ret)
{
	PyGILState_guard();

	_cleanup_pydecref_ PyObject *name_obj =
		PyUnicode_FromStringAndSize(name, name_len);
	if (!name_obj)
		return drgn_error_from_python();

	_cleanup_pydecref_ PyObject *kinds_obj = TypeKindSet_wrap(kinds);
	if (!kinds_obj)
		return drgn_error_from_python();
	_cleanup_pydecref_ PyObject *type_obj =
		PyObject_CallFunction(PyTuple_GET_ITEM(arg, 1), "OOOs",
				      PyTuple_GET_ITEM(arg, 0), kinds_obj,
				      name_obj, filename);
	if (!type_obj)
		return drgn_error_from_python();
	if (type_obj == Py_None)
		return &drgn_not_found;
	return py_type_find_fn_common(type_obj, arg, ret);
}

// Old version for add_type_finder().
static struct drgn_error *py_type_find_fn_old(uint64_t kinds, const char *name,
					      size_t name_len,
					      const char *filename, void *arg,
					      struct drgn_qualified_type *ret)
{
	PyGILState_guard();

	_cleanup_pydecref_ PyObject *name_obj =
		PyUnicode_FromStringAndSize(name, name_len);
	if (!name_obj)
		return drgn_error_from_python();

	int kind;
	for_each_bit(kind, kinds) {
		_cleanup_pydecref_ PyObject *
			kind_obj = PyObject_CallFunction(TypeKind_class, "i",
							 kind);
		if (!kind_obj)
			return drgn_error_from_python();
		_cleanup_pydecref_ PyObject *type_obj =
			PyObject_CallFunction(PyTuple_GET_ITEM(arg, 1), "OOs",
					      kind_obj, name_obj, filename);
		if (!type_obj)
			return drgn_error_from_python();
		if (type_obj == Py_None)
			continue;
		return py_type_find_fn_common(type_obj, arg, ret);
	}
	return &drgn_not_found;
}

static struct drgn_error *py_object_find_fn(const char *name, size_t name_len,
					    const char *filename,
					    enum drgn_find_object_flags flags,
					    void *arg, struct drgn_object *ret)
{
	PyGILState_guard();

	_cleanup_pydecref_ PyObject *name_obj =
		PyUnicode_FromStringAndSize(name, name_len);
	if (!name_obj)
		return drgn_error_from_python();
	_cleanup_pydecref_ PyObject *flags_obj =
		PyObject_CallFunction(FindObjectFlags_class, "i", (int)flags);
	if (!flags_obj)
		return drgn_error_from_python();
	_cleanup_pydecref_ PyObject *obj =
		PyObject_CallFunction(arg, "OOOs",
				      container_of(drgn_object_program(ret), Program, prog),
				      name_obj, flags_obj, filename);
	if (!obj)
		return drgn_error_from_python();
	if (obj == Py_None)
		return &drgn_not_found;
	if (!PyObject_TypeCheck(obj, &DrgnObject_type)) {
		PyErr_SetString(PyExc_TypeError,
				"object find callback must return Object or None");
		return drgn_error_from_python();
	}

	return drgn_object_copy(ret, &((DrgnObject *)obj)->obj);
}

static struct drgn_error *
py_symbol_find_fn(const char *name, uint64_t addr,
		  enum drgn_find_symbol_flags flags, void *arg,
		  struct drgn_symbol_result_builder *builder)
{
	// Fast path for SymbolIndex: don't bother converting to and from Python
	// types, as this is a C finder. Use Py_TYPE and pointer comparison
	// directly here to avoid needing to take the GIL for
	// PyObject_TypeCheck(). SymbolIndex cannot be subclassed, so the logic
	// for subclass checking is unnecessary anyway.
	if (Py_TYPE(PyTuple_GET_ITEM(arg, 1)) == &SymbolIndex_type) {
		SymbolIndex *ix = (SymbolIndex *)PyTuple_GET_ITEM(arg, 1);
		return drgn_symbol_index_find(name, addr, flags, &ix->index, builder);
	}

	PyGILState_guard();

	_cleanup_pydecref_ PyObject *name_obj = NULL;
	if (flags & DRGN_FIND_SYMBOL_NAME) {
		name_obj = PyUnicode_FromString(name);
		if (!name_obj)
			return drgn_error_from_python();
	} else {
		name_obj = Py_None;
		Py_INCREF(name_obj);
	}

	_cleanup_pydecref_ PyObject *address_obj = NULL;
	if (flags & DRGN_FIND_SYMBOL_ADDR) {
		address_obj = PyLong_FromUnsignedLong(addr);
		if (!address_obj)
			return drgn_error_from_python();
	} else {
		address_obj = Py_None;
		Py_INCREF(address_obj);
	}

	_cleanup_pydecref_ PyObject *one_obj = PyBool_FromLong(flags & DRGN_FIND_SYMBOL_ONE);

	_cleanup_pydecref_ PyObject *tmp =
		PyObject_CallFunction(PyTuple_GET_ITEM(arg, 1), "OOOO",
				      PyTuple_GET_ITEM(arg, 0), name_obj,
				      address_obj, one_obj);
	if (!tmp)
		return drgn_error_from_python();

	_cleanup_pydecref_ PyObject *obj =
		PySequence_Fast(tmp, "symbol finder must return a sequence");
	if (!obj)
		return drgn_error_from_python();

	size_t len = PySequence_Fast_GET_SIZE(obj);
	if (len > 1 && (flags & DRGN_FIND_SYMBOL_ONE))  {
		return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
					 "symbol finder returned multiple elements, but one was requested");
	}

	for (size_t i = 0; i < len; i++) {
		PyObject *item = PySequence_Fast_GET_ITEM(obj, i);
		if (!PyObject_TypeCheck(item, &Symbol_type))
			return drgn_error_create(DRGN_ERROR_TYPE,
						 "symbol finder results must be of type Symbol");
		_cleanup_free_ struct drgn_symbol *sym = malloc(sizeof(*sym));
		if (!sym)
			return &drgn_enomem;
		struct drgn_error *err = drgn_symbol_copy(sym, ((Symbol *)item)->sym);
		if (err)
			return err;

		if (!drgn_symbol_result_builder_add(builder, sym))
			return &drgn_enomem;
		sym = NULL; // owned by the builder now
	}

	return NULL;
}

#define debug_info_finder_arg(self, fn) PyObject *arg = fn;
#define type_finder_arg(self, fn)						\
	_cleanup_pydecref_ PyObject *arg = Py_BuildValue("OO", self, fn);	\
	if (!arg)								\
		return NULL;
#define object_finder_arg(self, fn) PyObject *arg = fn;
#define symbol_finder_arg type_finder_arg

#define DEFINE_PROGRAM_FINDER_METHODS(which)					\
static PyObject *Program_register_##which##_finder(Program *self,		\
						   PyObject *args,		\
						   PyObject *kwds)		\
{										\
	struct drgn_error *err;							\
	static char *keywords[] = {"name", "fn", "enable_index", NULL};		\
	const char *name;							\
	PyObject *fn;								\
	PyObject *enable_index_obj = Py_None;					\
	if (!PyArg_ParseTupleAndKeywords(args, kwds,				\
					 "sO|$O:register_" #which "_finder",	\
					 keywords, &name, &fn,			\
					 &enable_index_obj))			\
		return NULL;							\
										\
	if (!PyCallable_Check(fn)) {						\
		PyErr_SetString(PyExc_TypeError, "fn must be callable");	\
		return NULL;							\
	}									\
										\
	size_t enable_index;							\
	if (enable_index_obj == Py_None) {					\
		enable_index = DRGN_HANDLER_REGISTER_DONT_ENABLE;		\
	} else {								\
		_cleanup_pydecref_ PyObject *negative_one = PyLong_FromLong(-1);\
		if (!negative_one)						\
			return NULL;						\
		int eq = PyObject_RichCompareBool(enable_index_obj,		\
						  negative_one, Py_EQ);		\
		if (eq < 0)							\
			return NULL;						\
		if (eq) {							\
			enable_index = DRGN_HANDLER_REGISTER_ENABLE_LAST;	\
		} else {							\
			enable_index = PyLong_AsSize_t(enable_index_obj);	\
			if (enable_index == (size_t)-1 && PyErr_Occurred())	\
				return NULL;					\
			/*							\
			 * If the index happens to be the			\
			 * DRGN_HANDLER_REGISTER_DONT_ENABLE sentinel		\
			 * (SIZE_MAX - 1), set it to something else; it's	\
			 * impossible to have this many finders anyways.	\
			 */							\
			if (enable_index == DRGN_HANDLER_REGISTER_DONT_ENABLE)	\
				enable_index--;					\
		}								\
	}									\
										\
	which##_finder_arg(self, fn)						\
	if (!Program_hold_reserve(self, 1))					\
		return NULL;							\
	const struct drgn_##which##_finder_ops ops = {				\
		.find = py_##which##_find_fn,					\
	};									\
	err = drgn_program_register_##which##_finder(&self->prog, name, &ops,	\
						     arg, enable_index);	\
	if (err)								\
		return set_drgn_error(err);					\
	Program_hold_object(self, arg);						\
	Py_RETURN_NONE;								\
										\
}										\
										\
static PyObject *Program_registered_##which##_finders(Program *self)		\
{										\
	struct drgn_error *err;							\
	_cleanup_free_ const char **names = NULL;				\
	size_t count;								\
	err = drgn_program_registered_##which##_finders(&self->prog, &names,	\
							&count);		\
	if (err)								\
		return set_drgn_error(err);					\
	_cleanup_pydecref_ PyObject *res = PySet_New(NULL);			\
	if (!res)								\
		return NULL;							\
	for (size_t i = 0; i < count; i++) {					\
		_cleanup_pydecref_ PyObject *name =				\
			PyUnicode_FromString(names[i]);				\
		if (!name)							\
			return NULL;						\
		if (PySet_Add(res, name))					\
			return NULL;						\
	}									\
	return_ptr(res);							\
}										\
										\
static PyObject *Program_set_enabled_##which##_finders(Program *self,		\
						       PyObject *args,		\
						       PyObject *kwds)		\
{										\
	struct drgn_error *err;							\
	static char *keywords[] = {"names", NULL};				\
	PyObject *names_obj;							\
	if (!PyArg_ParseTupleAndKeywords(args, kwds,				\
					 "O:set_enabled_" #which "_finders",	\
					 keywords, &names_obj))			\
		return NULL;							\
	_cleanup_pydecref_ PyObject *names_seq =				\
		PySequence_Fast(names_obj, "names must be sequence");		\
	if (!names_seq)								\
		return NULL;							\
	size_t count = PySequence_Fast_GET_SIZE(names_seq);			\
	_cleanup_free_ const char **names =					\
		malloc_array(count, sizeof(names[0]));				\
	if (!names)								\
		return NULL;							\
	for (size_t i = 0; i < count; i++) {					\
		names[i] = PyUnicode_AsUTF8(PySequence_Fast_GET_ITEM(names_seq, i));\
		if (!names[i])							\
			return NULL;						\
	}									\
	err = drgn_program_set_enabled_##which##_finders(&self->prog, names,	\
							 count);		\
	if (err)								\
		return set_drgn_error(err);					\
	Py_RETURN_NONE;								\
}										\
										\
static PyObject *Program_enabled_##which##_finders(Program *self)		\
{										\
	struct drgn_error *err;							\
	_cleanup_free_ const char **names = NULL;				\
	size_t count;								\
	err = drgn_program_enabled_##which##_finders(&self->prog, &names,	\
						     &count);			\
	if (err)								\
		return set_drgn_error(err);					\
	_cleanup_pydecref_ PyObject *res = PyList_New(count);			\
	if (!res)								\
		return NULL;							\
	for (size_t i = 0; i < count; i++) {					\
		PyObject *name = PyUnicode_FromString(names[i]);		\
		if (!name)							\
			return NULL;						\
		PyList_SET_ITEM(res, i, name);					\
	}									\
	return_ptr(res);							\
}

DEFINE_PROGRAM_FINDER_METHODS(debug_info)
DEFINE_PROGRAM_FINDER_METHODS(type)
DEFINE_PROGRAM_FINDER_METHODS(object)
DEFINE_PROGRAM_FINDER_METHODS(symbol)

static PyObject *deprecated_finder_name_obj(PyObject *fn)
{
	_cleanup_pydecref_ PyObject *name_attr_obj =
		PyObject_GetAttrString(fn, "__name__");
	if (name_attr_obj) {
		return PyUnicode_FromFormat("%S_%lu", name_attr_obj, random());
	} else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
		PyErr_Clear();
		return PyUnicode_FromFormat("%lu", random());
	} else {
		return NULL;
	}
}

static PyObject *Program_add_type_finder(Program *self, PyObject *args,
					 PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"fn", NULL};
	PyObject *fn;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:add_type_finder",
					 keywords, &fn))
	    return NULL;

	if (!PyCallable_Check(fn)) {
		PyErr_SetString(PyExc_TypeError, "fn must be callable");
		return NULL;
	}

	_cleanup_pydecref_ PyObject *arg = Py_BuildValue("OO", self, fn);
	if (!arg)
		return NULL;

	_cleanup_pydecref_ PyObject *name_obj = deprecated_finder_name_obj(fn);
	if (!name_obj)
		return NULL;
	const char *name = PyUnicode_AsUTF8(name_obj);
	if (!name)
		return NULL;

	if (!Program_hold_reserve(self, 1))
		return NULL;
	const struct drgn_type_finder_ops ops = {
		.find = py_type_find_fn_old,
	};
	err = drgn_program_register_type_finder(&self->prog, name, &ops, arg,
						0);
	if (err)
		return set_drgn_error(err);
	Program_hold_object(self, arg);
	Py_RETURN_NONE;
}

static PyObject *Program_add_object_finder(Program *self, PyObject *args,
					   PyObject *kwds)
{
	struct drgn_error *err;

	static char *keywords[] = {"fn", NULL};
	PyObject *fn;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:add_object_finder",
					 keywords, &fn))
	    return NULL;

	if (!PyCallable_Check(fn)) {
		PyErr_SetString(PyExc_TypeError, "fn must be callable");
		return NULL;
	}

	_cleanup_pydecref_ PyObject *name_obj = deprecated_finder_name_obj(fn);
	if (!name_obj)
		return NULL;
	const char *name = PyUnicode_AsUTF8(name_obj);
	if (!name)
		return NULL;

	if (!Program_hold_reserve(self, 1))
		return NULL;
	const struct drgn_object_finder_ops ops = {
		.find = py_object_find_fn,
	};
	err = drgn_program_register_object_finder(&self->prog, name, &ops, fn,
						  0);
	if (err)
		return set_drgn_error(err);
	Program_hold_object(self, fn);
	Py_RETURN_NONE;
}

static PyObject *Program_set_core_dump(Program *self, PyObject *args,
				       PyObject *kwds)
{
	static char *keywords[] = {"path", NULL};
	struct drgn_error *err;
	PATH_ARG(path, .allow_fd = true);

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&:set_core_dump",
					 keywords, path_converter, &path))
		return NULL;

	if (path.fd >= 0)
		err = drgn_program_set_core_dump_fd(&self->prog, path.fd);
	else
		err = drgn_program_set_core_dump(&self->prog, path.path);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static PyObject *Program_set_kernel(Program *self)
{
	struct drgn_error *err;

	err = drgn_program_set_kernel(&self->prog);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static PyObject *Program_set_linux_kernel_custom(Program *self, PyObject *args,
						  PyObject *kwds)
{
	static char *keywords[] = {"vmcoreinfo", "is_live", NULL};
	struct drgn_error *err;
	const char *vmcoreinfo;
	Py_ssize_t vmcoreinfo_size;
	int is_live;

	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					 "s#p:set_linux_kernel_custom", keywords,
					 &vmcoreinfo, &vmcoreinfo_size,
					 &is_live))
		return NULL;

	err = drgn_program_set_linux_kernel_custom(&self->prog, vmcoreinfo,
						   vmcoreinfo_size, is_live);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static PyObject *Program_set_pid(Program *self, PyObject *args, PyObject *kwds)
{
	static char *keywords[] = {"pid", NULL};
	struct drgn_error *err;
	int pid;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i:set_pid", keywords,
					 &pid))
		return NULL;

	err = drgn_program_set_pid(&self->prog, pid);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static PyObject *Program_set_qemu_qmp(Program *self, PyObject *args,
				      PyObject *kwds)
{
	static char *keywords[] = {"address", NULL};
	struct drgn_error *err;
	PyObject *address;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:set_qemu_qmp", keywords,
					 &address))
		return NULL;

	if (PyIndex_Check(address)) {
		int overflow;
		long fd = PyLong_AsLongAndOverflow(address, &overflow);
		if (fd == -1 && PyErr_Occurred())
			return NULL;
		if (overflow > 0 || fd > INT_MAX) {
			PyErr_SetString(PyExc_OverflowError,
					"fd is greater than maximum");
			return NULL;
		}
		if (fd < 0) {
			PyErr_SetString(PyExc_ValueError, "fd is negative");
			return NULL;
		}
		err = drgn_program_set_qemu_qmp_fd(&self->prog, fd);
	} else if (PyUnicode_Check(address)) {
		const char *s = PyUnicode_AsUTF8(address);
		if (!s)
			return NULL;
		err = drgn_program_set_qemu_qmp(&self->prog, s);
	} else {
		return PyErr_Format(PyExc_TypeError,
				    "address must be str or int, not %s",
				    Py_TYPE(address)->tp_name);
	}
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static ModuleIterator *Program_modules(Program *self)
{
	struct drgn_error *err;
	ModuleIterator *it = call_tp_alloc(ModuleIterator);
	if (!it)
		return NULL;
	err = drgn_created_module_iterator_create(&self->prog, &it->it);
	if (err) {
		it->it = NULL;
		Py_DECREF(it);
		return set_drgn_error(err);
	}
	Py_INCREF(self);
	return it;
}

static ModuleIterator *Program_loaded_modules(Program *self)
{
	struct drgn_error *err;
	ModuleIterator *it =
		(ModuleIterator *)ModuleIteratorWithNew_type.tp_alloc(
					&ModuleIteratorWithNew_type, 0);
	if (!it)
		return NULL;
	err = drgn_loaded_module_iterator_create(&self->prog, &it->it);
	if (err) {
		it->it = NULL;
		Py_DECREF(it);
		return set_drgn_error(err);
	}
	Py_INCREF(self);
	return it;
}

static PyObject *Program_create_loaded_modules(Program *self)
{
	struct drgn_error *err = drgn_create_loaded_modules(&self->prog);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static inline PyObject *Module_wrap_find(struct drgn_module *module)
{
	if (module)
		return Module_wrap(module);
	PyErr_SetString(PyExc_LookupError, "module not found");
	return NULL;
}

static PyObject *Program_main_module(Program *self, PyObject *args,
				     PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"name", "create", NULL};
	PATH_ARG(name);
	int create = 0;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&$p:main_module",
					 keywords, path_converter, &name,
					 &create))
		return NULL;

	if (create) {
		if (!name.path) {
			PyErr_SetString(PyExc_TypeError,
					"name must be given if create=True");
			return NULL;
		}
		struct drgn_module *module;
		err = drgn_module_find_or_create_main(&self->prog, name.path,
						      &module, NULL);
		if (err) {
			set_drgn_error(err);
			return NULL;
		}
		return Module_wrap(module);
	} else {
		return Module_wrap_find(drgn_module_find_main(&self->prog,
							      name.path));
	}
}

static PyObject *Program_shared_library_module(Program *self, PyObject *args,
					       PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"name", "dynamic_address", "create", NULL};
	PATH_ARG(name);
	struct index_arg dynamic_address = {};
	int create = 0;
	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					 "O&O&|$p:shared_library_module",
					 keywords, path_converter, &name,
					 index_converter, &dynamic_address,
					 &create))
		return NULL;

	if (create) {
		struct drgn_module *module;
		err = drgn_module_find_or_create_shared_library(&self->prog,
								name.path,
								dynamic_address.uvalue,
								&module, NULL);
		if (err) {
			set_drgn_error(err);
			return NULL;
		}
		return Module_wrap(module);
	} else {
		return Module_wrap_find(drgn_module_find_shared_library(&self->prog,
									name.path,
									dynamic_address.uvalue));
	}
}

static PyObject *Program_vdso_module(Program *self, PyObject *args,
				     PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"name", "dynamic_address", "create", NULL};
	PATH_ARG(name);
	struct index_arg dynamic_address = {};
	int create = 0;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&|$p:vdso_module",
					 keywords, path_converter, &name,
					 index_converter, &dynamic_address,
					 &create))
		return NULL;

	if (create) {
		struct drgn_module *module;
		err = drgn_module_find_or_create_vdso(&self->prog, name.path,
						      dynamic_address.uvalue,
						      &module, NULL);
		if (err) {
			set_drgn_error(err);
			return NULL;
		}
		return Module_wrap(module);
	} else {
		return Module_wrap_find(drgn_module_find_vdso(&self->prog,
							      name.path,
							      dynamic_address.uvalue));
	}
}

static PyObject *Program_relocatable_module(Program *self, PyObject *args,
					    PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"name", "address", "create", NULL};
	PATH_ARG(name);
	struct index_arg address = {};
	int create = 0;
	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					 "O&O&|$p:relocatable_module", keywords,
					 path_converter, &name, index_converter,
					 &address, &create))
		return NULL;

	if (create) {
		struct drgn_module *module;
		err = drgn_module_find_or_create_relocatable(&self->prog,
							     name.path,
							     address.uvalue,
							     &module, NULL);
		if (err) {
			set_drgn_error(err);
			return NULL;
		}
		return Module_wrap(module);
	} else {
		return Module_wrap_find(drgn_module_find_relocatable(&self->prog,
								     name.path,
								     address.uvalue));
	}
}

static PyObject *Program_linux_kernel_loadable_module(Program *self,
						      PyObject *args,
						      PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"module_obj", "create", NULL};
	DrgnObject *module_obj;
	int create = 0;
	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					 "O!|$p:linux_kernel_loadable_module",
					 keywords, &DrgnObject_type,
					 &module_obj, &create))
		return NULL;

	if (DrgnObject_prog(module_obj) != self) {
		PyErr_SetString(PyExc_ValueError,
				"object is from different program");
		return NULL;
	}

	struct drgn_module *module;
	if (create) {
		err = drgn_module_find_or_create_linux_kernel_loadable(&module_obj->obj,
								       &module,
								       NULL);
		if (err) {
			set_drgn_error(err);
			return NULL;
		}
		return Module_wrap(module);
	} else {
		err = drgn_module_find_linux_kernel_loadable(&module_obj->obj,
							     &module);
		if (err) {
			set_drgn_error(err);
			return NULL;
		}
		return Module_wrap_find(module);
	}
}

static PyObject *Program_extra_module(Program *self, PyObject *args,
				      PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"name", "id", "create", NULL};
	PATH_ARG(name);
	struct index_arg id = {};
	int create = 0;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|O&$p:extra_module",
					 keywords, path_converter, &name,
					 index_converter, &id, &create))
		return NULL;

	if (create) {
		struct drgn_module *module;
		err = drgn_module_find_or_create_extra(&self->prog, name.path,
						       id.uvalue, &module,
						       NULL);
		if (err) {
			set_drgn_error(err);
			return NULL;
		}
		return Module_wrap(module);
	} else {
		return Module_wrap_find(drgn_module_find_extra(&self->prog,
							       name.path,
							       id.uvalue));
	}
}

static PyObject *Program_module(Program *self, PyObject *arg)
{
	struct drgn_module *module;
	if (PyUnicode_Check(arg)) {
		const char *name = PyUnicode_AsUTF8(arg);
		if (!name)
			return NULL;
		module = drgn_module_find_by_name(&self->prog, name);
	} else {
		struct index_arg address = {};
		if (!index_converter(arg, &address))
			return NULL;
		module = drgn_module_find_by_address(&self->prog,
						     address.uvalue);
	}
	return Module_wrap_find(module);
}

static DebugInfoOptions *Program_get_debug_info_options(Program *self, void *arg)
{
	DebugInfoOptions *options = call_tp_alloc(DebugInfoOptions);
	if (options) {
		options->options = drgn_program_debug_info_options(&self->prog);
		options->prog = self;
		Py_INCREF(self);
	}
	return options;
}

static int Program_set_debug_info_options(Program *self, PyObject *value, void *arg)
{
	SETTER_NO_DELETE("debug_info_options", value);
	if (!PyObject_TypeCheck(value, &DebugInfoOptions_type)) {
		PyErr_SetString(PyExc_TypeError,
				"debug_info_options must be DebugInfoOptions");
		return -1;
	}
	struct drgn_error *err =
		drgn_debug_info_options_copy(drgn_program_debug_info_options(&self->prog),
					     ((DebugInfoOptions *)value)->options);
	if (err) {
		set_drgn_error(err);
		return -1;
	}
	return 0;
}

static PyObject *Program_load_debug_info(Program *self, PyObject *args,
					 PyObject *kwds)
{
	static char *keywords[] = {"paths", "default", "main", NULL};
	struct drgn_error *err;
	PATH_SEQUENCE_ARG(paths, .allow_none = true);
	int load_default = 0;
	int load_main = 0;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&pp:load_debug_info",
					 keywords, path_sequence_converter,
					 &paths, &load_default, &load_main))
		return NULL;
	err = drgn_program_load_debug_info(&self->prog, paths.paths,
					   path_sequence_size(&paths),
					   load_default, load_main);
	if (err) {
		set_drgn_error(err);
		return NULL;
	}
	Py_RETURN_NONE;
}

static PyObject *Program_load_default_debug_info(Program *self)
{
	struct drgn_error *err;

	err = drgn_program_load_debug_info(&self->prog, NULL, 0, true, true);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static PyObject *Program_load_module_debug_info(Program *self, PyObject *args)
{
	size_t num_modules = PyTuple_GET_SIZE(args);
	_cleanup_free_ struct drgn_module **modules =
		malloc_array(num_modules, sizeof(*modules));
	if (!modules) {
		PyErr_NoMemory();
		return NULL;
	}

	for (size_t i = 0; i < num_modules; i++) {
		PyObject *item = PyTuple_GET_ITEM(args, i);
		if (!PyObject_TypeCheck(item, &Module_type)) {
			return PyErr_Format(PyExc_TypeError,
					    "expected Module, not %s",
					    Py_TYPE(item)->tp_name);
		}
		modules[i] = ((Module *)item)->module;
		if (modules[i]->prog != &self->prog) {
			PyErr_SetString(PyExc_ValueError,
					"module from wrong program");
			return NULL;
		}
	}

	struct drgn_error *err =
		drgn_load_module_debug_info(modules, &num_modules);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

DEFINE_VECTOR(drgn_module_vector, struct drgn_module *);

static PyObject *Program_find_standard_debug_info(Program *self, PyObject *args,
						  PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"modules", "options", NULL};
	PyObject *modules_obj;
	PyObject *options_obj = Py_None;
	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					 "O|O:find_standard_debug_info",
					 keywords, &modules_obj, &options_obj))
	    return NULL;

	_cleanup_pydecref_ PyObject *it = PyObject_GetIter(modules_obj);
	if (!it)
		return NULL;

	Py_ssize_t length_hint = PyObject_LengthHint(modules_obj, 1);
	if (length_hint == -1)
		return 0;

	VECTOR(drgn_module_vector, modules);
	if (!drgn_module_vector_reserve(&modules, length_hint))
		return PyErr_NoMemory();

	for (;;) {
		_cleanup_pydecref_ PyObject *item = PyIter_Next(it);
		if (!item)
			break;

		if (!PyObject_TypeCheck(item, &Module_type)) {
			return PyErr_Format(PyExc_TypeError,
					    "expected Module, not %s",
					    Py_TYPE(item)->tp_name);
		}
		struct drgn_module *module = ((Module *)item)->module;
		if (module->prog != &self->prog) {
			PyErr_SetString(PyExc_ValueError,
					"module from wrong program");
			return NULL;
		}
		if (!drgn_module_vector_append(&modules, &module))
			return PyErr_NoMemory();
	}
	if (PyErr_Occurred())
		return NULL;

	struct drgn_debug_info_options *options;
	if (options_obj == Py_None) {
		options = NULL;
	} else if (PyObject_TypeCheck(options_obj, &DebugInfoOptions_type)) {
		options = ((DebugInfoOptions *)options_obj)->options;
	} else {
		PyErr_SetString(PyExc_TypeError,
				"options must be DebugInfoOptions or None");
		return NULL;
	}

	err = drgn_find_standard_debug_info(drgn_module_vector_begin(&modules),
					    drgn_module_vector_size(&modules),
					    options);
	if (err)
		return set_drgn_error(err);
	Py_RETURN_NONE;
}

static PyObject *Program_read(Program *self, PyObject *args, PyObject *kwds)
{
	static char *keywords[] = {"address", "size", "physical", NULL};
	struct drgn_error *err;
	struct index_arg address = {};
	Py_ssize_t size;
	int physical = 0;
	bool clear;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&n|p:read", keywords,
					 index_converter, &address, &size,
					 &physical))
	    return NULL;

	if (size < 0) {
		PyErr_SetString(PyExc_ValueError, "negative size");
		return NULL;
	}
	_cleanup_pydecref_ PyObject *buf =
		PyBytes_FromStringAndSize(NULL, size);
	if (!buf)
		return NULL;
	clear = set_drgn_in_python();
	err = drgn_program_read_memory(&self->prog, PyBytes_AS_STRING(buf),
				       address.uvalue, size, physical);
	if (clear)
		clear_drgn_in_python();
	if (err)
		return set_drgn_error(err);
	return_ptr(buf);
}

static PyObject *Program_read_c_string(Program *self, PyObject *args,
				       PyObject *kwds)
{
	static char *keywords[] = {"address", "physical", "max_size", NULL};
	struct drgn_error *err;
	struct index_arg address = {};
	int physical = 0;
	Py_ssize_t max_size = PY_SSIZE_T_MAX;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|p$n:read_c_string",
					 keywords, index_converter, &address,
					 &physical, &max_size))
	    return NULL;

	if (max_size < 0) {
		PyErr_SetString(PyExc_ValueError, "negative max_size");
		return NULL;
	}
	bool clear = set_drgn_in_python();
	_cleanup_free_ char *str = NULL;
	err = drgn_program_read_c_string(&self->prog, address.uvalue, physical,
					 max_size, &str);
	if (clear)
		clear_drgn_in_python();
	if (err)
		return set_drgn_error(err);
	return PyBytes_FromString(str);
}

#define METHOD_READ(x, type)							\
static PyObject *Program_read_##x(Program *self, PyObject *args,		\
				  PyObject *kwds)				\
{										\
	static char *keywords[] = {"address", "physical", NULL};		\
	struct drgn_error *err;							\
	struct index_arg address = {};						\
	int physical = 0;							\
	type tmp;								\
										\
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|p:read_"#x, keywords,	\
					 index_converter, &address, &physical))	\
	    return NULL;							\
										\
	err = drgn_program_read_##x(&self->prog, address.uvalue, physical,	\
				    &tmp);					\
	if (err)								\
		return set_drgn_error(err);					\
	if (sizeof(tmp) <= sizeof(unsigned long))				\
		return PyLong_FromUnsignedLong(tmp);				\
	else									\
		return PyLong_FromUnsignedLongLong(tmp);			\
}
METHOD_READ(u8, uint8_t)
METHOD_READ(u16, uint16_t)
METHOD_READ(u32, uint32_t)
METHOD_READ(u64, uint64_t)
METHOD_READ(word, uint64_t)
#undef METHOD_READ

static PyObject *Program_search_memory(Program *self, PyObject *args,
				       PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"value", "alignment", NULL};
	PyObject *value_obj;
	PyObject *alignment_obj = Py_None;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|$O:search_memory",
					 keywords, &value_obj, &alignment_obj))
		return NULL;

	struct drgn_memory_search_iterator *it;
	if (PyObject_TypeCheck(value_obj, &PyBytes_Type)) {
		char *needle;
		Py_ssize_t size;
		if (PyBytes_AsStringAndSize(value_obj, &needle, &size))
			return NULL;

		uint64_t alignment;
		if (alignment_obj == Py_None)
			alignment = 1;
		else if (PyLong_AsUInt64(alignment_obj, &alignment))
			return NULL;

		err = drgn_program_search_memory(&self->prog, needle, size,
						 alignment, &it);
		if (err)
			return set_drgn_error(err);
	} else if (PyObject_TypeCheck(value_obj, &PyUnicode_Type)) {
		Py_ssize_t size;
		const char *needle = PyUnicode_AsUTF8AndSize(value_obj, &size);
		if (!needle)
			return NULL;

		uint64_t alignment;
		if (alignment_obj == Py_None)
			alignment = 1;
		else if (PyLong_AsUInt64(alignment_obj, &alignment))
			return NULL;

		err = drgn_program_search_memory(&self->prog, needle, size,
						 alignment, &it);
		if (err)
			return set_drgn_error(err);
	} else {
		if (alignment_obj != Py_None) {
			PyErr_SetString(PyExc_TypeError,
					"alignment is only allowed with bytes or str value");
			return NULL;
		}
		if (PyObject_TypeCheck(value_obj, &DrgnObject_type)) {
			err = drgn_search_memory_for_object(&((DrgnObject *)value_obj)->obj,
							    &it);
			if (err)
				return set_drgn_error(err);
		} else if (PyIndex_Check(value_obj)) {
			uint64_t value;
			if (PyLong_AsUInt64(value_obj, &value))
				return NULL;
			err = drgn_program_search_memory_word(&self->prog,
							      value, &it);
			if (err)
				return set_drgn_error(err);
		} else {
			return PyErr_Format(PyExc_TypeError,
					    "value must be bytes, str, int, "
					    "or drgn.Object, not %.200s",
					    Py_TYPE(value_obj)->tp_name);
		}
	}

	PyObject *ret =
		MemorySearchIterator_wrap(&MemorySearchIterator_type, it);
	if (!ret)
		drgn_memory_search_iterator_destroy(it);
	return ret;
}

#define X(bits)									\
DEFINE_VECTOR(uint##bits##_vector, uint##bits##_t);				\
DEFINE_VECTOR(uint##bits##_range_vector, uint##bits##_t [2]);			\
static PyObject *Program_search_memory_u##bits(Program *self, PyObject *args,	\
					       PyObject *kwds)			\
{										\
	struct drgn_error *err;							\
										\
	static char *keywords[] = {"ignore_mask", NULL};			\
	_cleanup_pydecref_ PyObject *empty_tuple = PyTuple_New(0);		\
	if (!empty_tuple)							\
		return NULL;							\
	PyObject *ignore_mask_obj = NULL;					\
	if (!PyArg_ParseTupleAndKeywords(empty_tuple, kwds,			\
					 "|$O:search_memory_u" #bits,		\
					 keywords, &ignore_mask_obj))		\
		return NULL;							\
										\
	VECTOR(uint##bits##_vector, values);					\
	VECTOR(uint##bits##_range_vector, ranges);				\
										\
	Py_ssize_t num_args = PyTuple_GET_SIZE(args);				\
	for (Py_ssize_t i = 0; i < num_args; i++) {				\
		PyObject *item = PyTuple_GET_ITEM(args, i);			\
		if (PyTuple_Check(item)) {					\
			if (PyTuple_GET_SIZE(item) != 2) {			\
				PyErr_SetString(PyExc_TypeError,		\
						"values must be int or (int, int)");\
				return NULL;					\
			}							\
			uint##bits##_t (*entry)[2] =				\
				uint##bits##_range_vector_append_entry(&ranges);\
			if (!entry)						\
				return PyErr_NoMemory();			\
			if (PyLong_AsUInt##bits(PyTuple_GET_ITEM(item, 0),	\
						&(*entry)[0])			\
			    || PyLong_AsUInt##bits(PyTuple_GET_ITEM(item, 1),	\
						   &(*entry)[1]))		\
				return NULL;					\
		} else {							\
			uint##bits##_t *entry =					\
				uint##bits##_vector_append_entry(&values);	\
			if (!entry)						\
				return PyErr_NoMemory();			\
			if (PyLong_AsUInt##bits(item, entry))			\
				return NULL;					\
		}								\
	}									\
										\
	uint##bits##_t ignore_mask;						\
	if (!ignore_mask_obj)							\
		ignore_mask = 0;						\
	else if (PyLong_AsUInt##bits(ignore_mask_obj, &ignore_mask))		\
		return NULL;							\
										\
	struct drgn_memory_search_iterator *it;					\
	err = drgn_program_search_memory_u##bits##_multi(&self->prog,		\
				uint##bits##_vector_begin(&values),		\
				uint##bits##_vector_size(&values),		\
				ignore_mask,					\
				uint##bits##_range_vector_begin(&ranges),	\
				uint##bits##_range_vector_size(&ranges), &it);	\
	if (err)								\
		return set_drgn_error(err);					\
	PyObject *ret =								\
		MemorySearchIterator_wrap(&MemorySearchIteratorWithInt_type,	\
					  it);					\
	if (!ret)								\
		drgn_memory_search_iterator_destroy(it);			\
	return ret;								\
}
SEARCH_MEMORY_UINT_SIZES
#undef X

static PyObject *Program_search_memory_word(Program *self, PyObject *args,
					    PyObject *kwds)
{
	struct drgn_error *err;
	bool is_64_bit;
	err = drgn_program_is_64_bit(&self->prog, &is_64_bit);
	if (err)
		return set_drgn_error(err);
	return (is_64_bit
		? Program_search_memory_u64
		: Program_search_memory_u32)(self, args, kwds);
}

static PyObject *Program_search_memory_regex(Program *self, PyObject *args,
					     PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"pattern", NULL};
	PyObject *pattern_obj;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|$:search_memory_regex",
					 keywords, &pattern_obj))
		return NULL;

	const char *pattern;
	Py_ssize_t pattern_len;
	bool utf8;
	if (PyObject_TypeCheck(pattern_obj, &PyBytes_Type)) {
		if (PyBytes_AsStringAndSize(pattern_obj, (char **)&pattern,
					    &pattern_len))
			return NULL;
		utf8 = false;
	} else if (PyObject_TypeCheck(pattern_obj, &PyUnicode_Type)) {
		pattern = PyUnicode_AsUTF8AndSize(pattern_obj, &pattern_len);
		if (!pattern)
			return NULL;
		utf8 = true;
	} else {
		PyErr_SetString(PyExc_TypeError,
				"pattern must be bytes or str");
		return NULL;
	}

	struct drgn_memory_search_iterator *it;
	err = drgn_program_search_memory_regex(&self->prog, pattern,
					       pattern_len, utf8, &it);
	if (err)
		return set_drgn_error(err);
	PyObject *ret =
		MemorySearchIterator_wrap(utf8
					  ? &MemorySearchIteratorWithStr_type
					  : &MemorySearchIteratorWithBytes_type,
					  it);
	if (!ret)
		drgn_memory_search_iterator_destroy(it);
	return ret;
}

static PyObject *Program_find_type(Program *self, PyObject *args, PyObject *kwds)
{
	static char *keywords[] = {"name", "filename", NULL};
	struct drgn_error *err;
	PyObject *name_or_type;
	PATH_ARG(filename, .allow_none = true);
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:type", keywords,
					 &name_or_type, path_converter,
					 &filename))
		return NULL;

	if (PyObject_TypeCheck(name_or_type, &DrgnType_type)) {
		if (DrgnType_prog((DrgnType *)name_or_type) != self) {
			PyErr_SetString(PyExc_ValueError,
					"type is from different program");
			return NULL;
		}
		Py_INCREF(name_or_type);
		return name_or_type;
	} else if (!PyUnicode_Check(name_or_type)) {
		PyErr_SetString(PyExc_TypeError,
				"type() argument 1 must be str or Type");
		return NULL;
	}

	const char *name = PyUnicode_AsUTF8(name_or_type);
	if (!name)
		return NULL;
	bool clear = set_drgn_in_python();
	struct drgn_qualified_type qualified_type;
	err = drgn_program_find_type(&self->prog, name, filename.path,
				     &qualified_type);
	if (clear)
		clear_drgn_in_python();
	if (err) {
		set_drgn_error(err);
		return NULL;
	}
	return DrgnType_wrap(qualified_type);
}

static void *set_object_not_found_error(struct drgn_error *err, PyObject *name)
{
	_cleanup_pydecref_ PyObject *args = Py_BuildValue("(s)", err->message);
	drgn_error_destroy(err);
	if (!args)
		return NULL;

	_cleanup_pydecref_ PyObject *kwargs =
		Py_BuildValue("{sO}", "name", name);
	if (!kwargs)
		return NULL;

	_cleanup_pydecref_ PyObject *exc =
		PyObject_Call((PyObject *)&ObjectNotFoundError_type, args,
			      kwargs);
	if (exc)
		PyErr_SetObject((PyObject *)&ObjectNotFoundError_type, exc);
	return NULL;
}

static DrgnObject *Program_find_object(Program *self, PyObject *name_obj,
				       const char *filename,
				       enum drgn_find_object_flags flags)
{
	struct drgn_error *err;

	if (!PyUnicode_Check(name_obj)) {
		PyErr_Format(PyExc_TypeError, "name must be str, not %.200s",
			     Py_TYPE(name_obj)->tp_name);
		return NULL;
	}
	const char *name = PyUnicode_AsUTF8(name_obj);
	if (!name)
		return NULL;

	_cleanup_pydecref_ DrgnObject *ret = DrgnObject_alloc(self);
	if (!ret)
		return NULL;
	bool clear = set_drgn_in_python();
	err = drgn_program_find_object(&self->prog, name, filename, flags,
				       &ret->obj);
	if (clear)
		clear_drgn_in_python();
	if (err && err->code == DRGN_ERROR_LOOKUP)
		return set_object_not_found_error(err, name_obj);
	else if (err)
		return set_drgn_error(err);
	return_ptr(ret);
}

static DrgnObject *Program_object(Program *self, PyObject *args,
				  PyObject *kwds)
{
	static char *keywords[] = {"name", "flags", "filename", NULL};
	PyObject *name;
	struct enum_arg flags = {
		.type = FindObjectFlags_class,
		.value = DRGN_FIND_OBJECT_ANY,
	};
	PATH_ARG(filename, .allow_none = true);
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&:object", keywords,
					 &name, enum_converter, &flags,
					 path_converter, &filename))
		return NULL;

	return Program_find_object(self, name, filename.path, flags.value);
}

static DrgnObject *Program_constant(Program *self, PyObject *args,
				    PyObject *kwds)
{
	static char *keywords[] = {"name", "filename", NULL};
	PyObject *name;
	PATH_ARG(filename, .allow_none = true);
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:constant", keywords,
					 &name, path_converter, &filename))
		return NULL;

	return Program_find_object(self, name, filename.path,
				   DRGN_FIND_OBJECT_CONSTANT);
}

static DrgnObject *Program_function(Program *self, PyObject *args,
				    PyObject *kwds)
{
	static char *keywords[] = {"name", "filename", NULL};
	PyObject *name;
	PATH_ARG(filename, .allow_none = true);
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:function", keywords,
					 &name, path_converter, &filename))
		return NULL;

	return Program_find_object(self, name, filename.path,
				   DRGN_FIND_OBJECT_FUNCTION);
}

static DrgnObject *Program_variable(Program *self, PyObject *args,
				    PyObject *kwds)
{
	static char *keywords[] = {"name", "filename", NULL};
	PyObject *name;
	PATH_ARG(filename, .allow_none = true);
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:variable", keywords,
					 &name, path_converter, &filename))
		return NULL;

	return Program_find_object(self, name, filename.path,
				   DRGN_FIND_OBJECT_VARIABLE);
}

static PyObject *Program_stack_trace(Program *self, PyObject *args,
				     PyObject *kwds)
{
	static char *keywords[] = {"thread", NULL};
	struct drgn_error *err;
	PyObject *thread;
	struct drgn_stack_trace *trace;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:stack_trace", keywords,
					 &thread))
		return NULL;

	if (PyObject_TypeCheck(thread, &DrgnObject_type)) {
		err = drgn_object_stack_trace(&((DrgnObject *)thread)->obj,
					      &trace);
	} else {
		struct index_arg tid = {};

		if (!index_converter(thread, &tid))
			return NULL;
		err = drgn_program_stack_trace(&self->prog, tid.uvalue, &trace);
	}
	if (err)
		return set_drgn_error(err);

	PyObject *ret = StackTrace_wrap(trace);
	if (!ret)
		drgn_stack_trace_destroy(trace);
	return ret;
}

static PyObject *Program_stack_trace_from_pcs(Program *self, PyObject *args,
					      PyObject *kwds)
{
	static char *keywords[] = {"pcs", NULL};
	struct drgn_error *err;
	PyObject *pypcs;
	struct drgn_stack_trace *trace;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:stack_trace_from_pcs",
					 keywords, &pypcs))
		return NULL;

	_cleanup_pydecref_ PyObject *pypcseq = PySequence_Fast(
		pypcs, "stack_trace_from_pcs() argument 1 must be a list");
	if (!pypcseq)
		return NULL;

	size_t size = PySequence_Fast_GET_SIZE(pypcseq);
	_cleanup_free_ uint64_t *pcs = malloc_array(size, sizeof(uint64_t));
	for (uint64_t i = 0; i != size; ++i) {
		struct index_arg pc = {};

		if (!index_converter(PySequence_Fast_GET_ITEM(pypcseq, i), &pc))
			return NULL;
		pcs[i] = pc.uvalue;
	}

	err = drgn_program_stack_trace_from_pcs(&self->prog, pcs, size, &trace);
	if (err)
		return set_drgn_error(err);

	PyObject *ret = StackTrace_wrap(trace);
	if (!ret)
		drgn_stack_trace_destroy(trace);
	return ret;
}

static PyObject *Program_source_location(Program *self, PyObject *arg)
{
	struct drgn_error *err;

	struct drgn_source_location_list *locs;
	if (PyUnicode_Check(arg)) {
		const char *address_str = PyUnicode_AsUTF8(arg);
		if (!address_str)
			return NULL;
		err = drgn_program_addr2line(&self->prog, address_str, &locs);
	} else {
		struct index_arg address = {};
		if (!index_converter(arg, &address))
			return NULL;
		err = drgn_program_source_location(&self->prog, address.uvalue,
						   &locs);
	}
	if (err)
		return set_drgn_error(err);

	PyObject *ret = SourceLocationList_wrap(locs);
	if (!ret)
		drgn_source_location_list_destroy(locs);
	return ret;
}

static PyObject *Program_symbols(Program *self, PyObject *args)
{
	struct drgn_error *err;

	PyObject *arg = Py_None;
	if (!PyArg_ParseTuple(args, "|O:symbols", &arg))
		return NULL;

	struct drgn_symbol **symbols;
	size_t count;
	if (arg == Py_None) {
		err = drgn_program_find_symbols_by_name(&self->prog, NULL,
							&symbols, &count);
	} else if (PyUnicode_Check(arg)) {
		const char *name = PyUnicode_AsUTF8(arg);
		if (!name)
			return NULL;
		err = drgn_program_find_symbols_by_name(&self->prog, name,
							&symbols, &count);
	} else {
		struct index_arg address = {};
		if (!index_converter(arg, &address))
			return NULL;
		err = drgn_program_find_symbols_by_address(&self->prog,
							   address.uvalue,
							   &symbols, &count);
	}
	if (err)
		return set_drgn_error(err);

	return Symbol_list_wrap(symbols, count, (PyObject *)self);
}

static PyObject *Program_symbol(Program *self, PyObject *arg)
{
	struct drgn_error *err;
	struct drgn_symbol *sym;
	PyObject *ret;

	if (PyUnicode_Check(arg)) {
		const char *name;

		name = PyUnicode_AsUTF8(arg);
		if (!name)
			return NULL;
		err = drgn_program_find_symbol_by_name(&self->prog, name, &sym);
	} else {
		struct index_arg address = {};

		if (!index_converter(arg, &address))
			return NULL;
		err = drgn_program_find_symbol_by_address(&self->prog,
							  address.uvalue, &sym);
	}
	if (err)
		return set_drgn_error(err);
	ret = Symbol_wrap(sym, (PyObject *)self);
	if (!ret) {
		drgn_symbol_destroy(sym);
		return NULL;
	}
	return ret;
}

static ThreadIterator *Program_threads(Program *self)
{
	struct drgn_thread_iterator *it;
	struct drgn_error *err = drgn_thread_iterator_create(&self->prog, &it);
	if (err)
		return set_drgn_error(err);
	ThreadIterator *ret = call_tp_alloc(ThreadIterator);
	if (!ret) {
		drgn_thread_iterator_destroy(it);
		return NULL;
	}
	ret->prog = self;
	ret->iterator = it;
	Py_INCREF(self);
	return ret;
}

static PyObject *Program_thread(Program *self, PyObject *args, PyObject *kwds)
{
	static char *keywords[] = {"tid", NULL};
	struct drgn_error *err;
	struct index_arg tid = {};

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&:thread", keywords,
					 index_converter, &tid))
		return NULL;

	struct drgn_thread *thread;
	err = drgn_program_find_thread(&self->prog, tid.uvalue, &thread);
	if (err)
		return set_drgn_error(err);
	if (!thread) {
		return PyErr_Format(PyExc_LookupError,
				    "thread with ID %llu not found",
				    tid.uvalue);
	}
	PyObject *ret = Thread_wrap(thread);
	drgn_thread_destroy(thread);
	return ret;
}

static PyObject *Program_main_thread(Program *self)
{
	struct drgn_error *err;
	struct drgn_thread *thread;
	err = drgn_program_main_thread(&self->prog, &thread);
	if (err)
		return set_drgn_error(err);
	return Thread_wrap(thread);
}

static PyObject *Program_crashed_thread(Program *self)
{
	struct drgn_error *err;
	struct drgn_thread *thread;
	err = drgn_program_crashed_thread(&self->prog, &thread);
	if (err)
		return set_drgn_error(err);
	return Thread_wrap(thread);
}

static PyObject *Program_address_size(Program *self)
{
	struct drgn_error *err;
	uint64_t address_size;
	err = drgn_program_address_size(&self->prog, &address_size);
	if (err)
		return set_drgn_error(err);
	return PyLong_FromUInt64(address_size);
}

// Used for testing.
static PyObject *Program__log(Program *self, PyObject *args, PyObject *kwds)
{
	int level;
	const char *str;
	if (!PyArg_ParseTuple(args, "is", &level, &str))
		return NULL;
	drgn_log(level, &self->prog, "%s", str);
	Py_RETURN_NONE;
}

static DrgnObject *Program_subscript(Program *self, PyObject *key)
{
	if (!PyUnicode_Check(key)) {
		PyErr_SetObject(PyExc_KeyError, key);
		return NULL;
	}
	return Program_find_object(self, key, NULL, DRGN_FIND_OBJECT_ANY);
}

static int Program_contains(Program *self, PyObject *key)
{
	struct drgn_error *err;

	if (!PyUnicode_Check(key)) {
		PyErr_SetObject(PyExc_KeyError, key);
		return 0;
	}

	const char *name = PyUnicode_AsUTF8(key);
	if (!name)
		return -1;

	DRGN_OBJECT(tmp, &self->prog);
	bool clear = set_drgn_in_python();
	err = drgn_program_find_object(&self->prog, name, NULL,
				       DRGN_FIND_OBJECT_ANY, &tmp);
	if (clear)
		clear_drgn_in_python();
	if (err) {
		if (err->code == DRGN_ERROR_LOOKUP) {
			drgn_error_destroy(err);
			return 0;
		} else {
			set_drgn_error(err);
			return -1;
		}
	}
	return 1;
}

static PyObject *Program_get_flags(Program *self, void *arg)
{
	return PyObject_CallFunction(ProgramFlags_class, "k",
				     (unsigned long)self->prog.flags);
}

static PyObject *Program_get_platform(Program *self, void *arg)
{
	const struct drgn_platform *platform;

	platform = drgn_program_platform(&self->prog);
	if (platform)
		return Platform_wrap(platform);
	else
		Py_RETURN_NONE;
}

static PyObject *Program_get_core_dump_path(Program *self, void *arg)
{
	const char *path = drgn_program_core_dump_path(&self->prog);
	if (!path)
		Py_RETURN_NONE;
	return PyUnicode_FromString(path);
}

static PyObject *Program_get_language(Program *self, void *arg)
{
	return Language_wrap(drgn_program_language(&self->prog));
}

static int Program_set_language(Program *self, PyObject *value, void *arg)
{
	SETTER_NO_DELETE("language", value);
	if (!PyObject_TypeCheck(value, &Language_type)) {
		PyErr_SetString(PyExc_TypeError, "language must be Language");
		return -1;
	}
	drgn_program_set_language(&self->prog, ((Language *)value)->language);
	return 0;
}

#define PROGRAM_FINDER_METHOD_DEFS(which)					\
	{"register_" #which "_finder",						\
	 (PyCFunction)Program_register_##which##_finder,			\
	 METH_VARARGS | METH_KEYWORDS,						\
	 drgn_Program_register_##which##_finder_DOC},				\
	{"registered_" #which "_finders",					\
	 (PyCFunction)Program_registered_##which##_finders, METH_NOARGS,	\
	 drgn_Program_registered_##which##_finders_DOC},			\
	{"set_enabled_" #which "_finders",					\
	 (PyCFunction)Program_set_enabled_##which##_finders,			\
	 METH_VARARGS | METH_KEYWORDS,						\
	 drgn_Program_set_enabled_##which##_finders_DOC},			\
	{"enabled_" #which "_finders",						\
	 (PyCFunction)Program_enabled_##which##_finders, METH_NOARGS,		\
	 drgn_Program_enabled_##which##_finders_DOC}

static PyMethodDef Program_methods[] = {
	{"add_memory_segment", (PyCFunction)Program_add_memory_segment,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_add_memory_segment_DOC},
	PROGRAM_FINDER_METHOD_DEFS(debug_info),
	PROGRAM_FINDER_METHOD_DEFS(type),
	PROGRAM_FINDER_METHOD_DEFS(object),
	PROGRAM_FINDER_METHOD_DEFS(symbol),
	{"add_type_finder", (PyCFunction)Program_add_type_finder,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_add_type_finder_DOC},
	{"add_object_finder", (PyCFunction)Program_add_object_finder,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_add_object_finder_DOC},
	{"set_core_dump", (PyCFunction)Program_set_core_dump,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_set_core_dump_DOC},
	{"set_kernel", (PyCFunction)Program_set_kernel, METH_NOARGS,
	 drgn_Program_set_kernel_DOC},
	{"set_linux_kernel_custom", (PyCFunction)Program_set_linux_kernel_custom,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_set_linux_kernel_custom_DOC},
	{"set_pid", (PyCFunction)Program_set_pid, METH_VARARGS | METH_KEYWORDS,
	 drgn_Program_set_pid_DOC},
	{"set_qemu_qmp", (PyCFunction)Program_set_qemu_qmp,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_set_qemu_qmp_DOC},
	{"modules", (PyCFunction)Program_modules, METH_NOARGS,
	 drgn_Program_modules_DOC},
	{"loaded_modules", (PyCFunction)Program_loaded_modules, METH_NOARGS,
	 drgn_Program_loaded_modules_DOC},
	{"create_loaded_modules", (PyCFunction)Program_create_loaded_modules,
	 METH_NOARGS, drgn_Program_create_loaded_modules_DOC},
	{"main_module", (PyCFunction)Program_main_module,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_main_module_DOC},
	{"shared_library_module", (PyCFunction)Program_shared_library_module,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_shared_library_module_DOC},
	{"vdso_module", (PyCFunction)Program_vdso_module,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_vdso_module_DOC},
	{"relocatable_module", (PyCFunction)Program_relocatable_module,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_relocatable_module_DOC},
	{"linux_kernel_loadable_module",
	 (PyCFunction)Program_linux_kernel_loadable_module,
	 METH_VARARGS | METH_KEYWORDS,
	 drgn_Program_linux_kernel_loadable_module_DOC},
	{"extra_module", (PyCFunction)Program_extra_module,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_extra_module_DOC},
	{"module", (PyCFunction)Program_module, METH_O,
	 drgn_Program_module_DOC},
	{"load_debug_info", (PyCFunction)Program_load_debug_info,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_load_debug_info_DOC},
	{"load_default_debug_info",
	 (PyCFunction)Program_load_default_debug_info, METH_NOARGS,
	 drgn_Program_load_default_debug_info_DOC},
	{"load_module_debug_info", (PyCFunction)Program_load_module_debug_info,
	 METH_VARARGS, drgn_Program_load_module_debug_info_DOC},
	{"find_standard_debug_info",
	 (PyCFunction)Program_find_standard_debug_info,
	 METH_VARARGS | METH_KEYWORDS,
	 drgn_Program_find_standard_debug_info_DOC},
	{"__getitem__", (PyCFunction)Program_subscript, METH_O | METH_COEXIST,
	 drgn_Program___getitem___DOC},
	{"__contains__", (PyCFunction)Program_contains, METH_O | METH_COEXIST,
	 drgn_Program___contains___DOC},
	{"read", (PyCFunction)Program_read, METH_VARARGS | METH_KEYWORDS,
	 drgn_Program_read_DOC},
	{"read_c_string", (PyCFunction)Program_read_c_string,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_read_c_string_DOC},
#define METHOD_DEF_READ(x)						\
	{"read_"#x, (PyCFunction)Program_read_##x,			\
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_read_##x##_DOC}
	METHOD_DEF_READ(u8),
	METHOD_DEF_READ(u16),
	METHOD_DEF_READ(u32),
	METHOD_DEF_READ(u64),
	METHOD_DEF_READ(word),
#undef METHOD_READ_U
	{"search_memory", (PyCFunction)Program_search_memory,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_search_memory_DOC},
#define X(bits)									\
	{"search_memory_u" #bits, (PyCFunction)Program_search_memory_u##bits,	\
	 METH_VARARGS | METH_KEYWORDS,						\
	 drgn_Program_search_memory_u##bits##_DOC},
	SEARCH_MEMORY_UINT_SIZES
#undef X
	{"search_memory_word", (PyCFunction)Program_search_memory_word,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_search_memory_word_DOC},
	{"search_memory_regex", (PyCFunction)Program_search_memory_regex,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_search_memory_regex_DOC},
	{"type", (PyCFunction)Program_find_type, METH_VARARGS | METH_KEYWORDS,
	 drgn_Program_type_DOC},
	{"object", (PyCFunction)Program_object, METH_VARARGS | METH_KEYWORDS,
	 drgn_Program_object_DOC},
	{"constant", (PyCFunction)Program_constant,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_constant_DOC},
	{"function", (PyCFunction)Program_function,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_function_DOC},
	{"variable", (PyCFunction)Program_variable,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_variable_DOC},
	{"stack_trace", (PyCFunction)Program_stack_trace,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_stack_trace_DOC},
	{"stack_trace_from_pcs", (PyCFunction)Program_stack_trace_from_pcs,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_stack_trace_from_pcs_DOC},
	{"source_location", (PyCFunction)Program_source_location, METH_O,
	 drgn_Program_source_location_DOC},
	{"symbols", (PyCFunction)Program_symbols, METH_VARARGS,
	 drgn_Program_symbols_DOC},
	{"symbol", (PyCFunction)Program_symbol, METH_O,
	 drgn_Program_symbol_DOC},
	{"threads", (PyCFunction)Program_threads, METH_NOARGS,
	 drgn_Program_threads_DOC},
	{"thread", (PyCFunction)Program_thread,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_thread_DOC},
	{"main_thread", (PyCFunction)Program_main_thread, METH_NOARGS,
	 drgn_Program_main_thread_DOC},
	{"crashed_thread", (PyCFunction)Program_crashed_thread, METH_NOARGS,
	 drgn_Program_crashed_thread_DOC},
	{"address_size", (PyCFunction)Program_address_size, METH_NOARGS,
	 drgn_Program_address_size_DOC},
	{"void_type", (PyCFunction)Program_void_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_void_type_DOC},
	{"int_type", (PyCFunction)Program_int_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_int_type_DOC},
	{"bool_type", (PyCFunction)Program_bool_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_bool_type_DOC},
	{"float_type", (PyCFunction)Program_float_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_float_type_DOC},
	{"struct_type", (PyCFunction)Program_struct_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_struct_type_DOC},
	{"union_type", (PyCFunction)Program_union_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_union_type_DOC},
	{"class_type", (PyCFunction)Program_class_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_class_type_DOC},
	{"enum_type", (PyCFunction)Program_enum_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_enum_type_DOC},
	{"typedef_type", (PyCFunction)Program_typedef_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_typedef_type_DOC},
	{"pointer_type", (PyCFunction)Program_pointer_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_pointer_type_DOC},
	{"array_type", (PyCFunction)Program_array_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_array_type_DOC},
	{"function_type", (PyCFunction)Program_function_type,
	 METH_VARARGS | METH_KEYWORDS, drgn_Program_function_type_DOC},
	{"_log", (PyCFunction)Program__log, METH_VARARGS},
	{},
};

static PyMemberDef Program_members[] = {
	{"cache", T_OBJECT_EX, offsetof(Program, cache), 0,
	 drgn_Program_cache_DOC},
	{"config", T_OBJECT_EX, offsetof(Program, config), 0,
	 drgn_Program_config_DOC},
	{},
};

static PyGetSetDef Program_getset[] = {
	{"flags", (getter)Program_get_flags, NULL, drgn_Program_flags_DOC},
	{"platform", (getter)Program_get_platform, NULL,
	 drgn_Program_platform_DOC},
	{"core_dump_path", (getter)Program_get_core_dump_path, NULL,
	 drgn_Program_core_dump_path_DOC},
	{"language", (getter)Program_get_language, (setter)Program_set_language,
	 drgn_Program_language_DOC},
	{"debug_info_options", (getter)Program_get_debug_info_options,
	 (setter)Program_set_debug_info_options,
	 drgn_Program_debug_info_options_DOC},
	{},
};

static PyMappingMethods Program_as_mapping = {
	.mp_subscript = (binaryfunc)Program_subscript,
};

static PySequenceMethods Program_as_sequence = {
	.sq_contains = (objobjproc)Program_contains,
};

PyTypeObject Program_type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "_drgn.Program",
	.tp_basicsize = sizeof(Program),
	.tp_dealloc = (destructor)Program_dealloc,
	.tp_as_sequence = &Program_as_sequence,
	.tp_as_mapping = &Program_as_mapping,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
	.tp_doc = drgn_Program_DOC,
	.tp_traverse = (traverseproc)Program_traverse,
	.tp_clear = (inquiry)Program_clear,
	.tp_methods = Program_methods,
	.tp_members = Program_members,
	.tp_getset = Program_getset,
	.tp_new = (newfunc)Program_new,
};

Program *program_from_core_dump(PyObject *self, PyObject *args, PyObject *kwds)
{
	static char *keywords[] = {"path", NULL};
	struct drgn_error *err;
	PATH_ARG(path, .allow_fd = true);
	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					 "O&:program_from_core_dump", keywords,
					 path_converter, &path))
		return NULL;

	_cleanup_pydecref_ Program *prog =
		(Program *)PyObject_CallObject((PyObject *)&Program_type, NULL);
	if (!prog)
		return NULL;

	if (path.fd >= 0)
		err = drgn_program_init_core_dump_fd(&prog->prog, path.fd);
	else
		err = drgn_program_init_core_dump(&prog->prog, path.path);
	if (err)
		return set_drgn_error(err);
	return_ptr(prog);
}

Program *program_from_kernel(PyObject *self)
{
	struct drgn_error *err;
	_cleanup_pydecref_ Program *prog =
		(Program *)PyObject_CallObject((PyObject *)&Program_type, NULL);
	if (!prog)
		return NULL;
	err = drgn_program_init_kernel(&prog->prog);
	if (err)
		return set_drgn_error(err);
	return_ptr(prog);
}

Program *program_from_pid(PyObject *self, PyObject *args, PyObject *kwds)
{
	struct drgn_error *err;
	static char *keywords[] = {"pid", NULL};
	int pid;
	if (!PyArg_ParseTupleAndKeywords(args, kwds, "i:program_from_pid",
					 keywords, &pid))
		return NULL;

	_cleanup_pydecref_ Program *prog =
		(Program *)PyObject_CallObject((PyObject *)&Program_type, NULL);
	if (!prog)
		return NULL;
	err = drgn_program_init_pid(&prog->prog, pid);
	if (err)
		return set_drgn_error(err);
	return_ptr(prog);
}
