1 /* Python interface to inferiors.
3 Copyright (C) 2009-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdbthread.h"
26 #include "python-internal.h"
27 #include "arch-utils.h"
29 #include "gdb_signals.h"
31 #include "py-stopevent.h"
33 struct threadlist_entry {
34 thread_object *thread_obj;
35 struct threadlist_entry *next;
42 /* The inferior we represent. */
43 struct inferior *inferior;
45 /* thread_object instances under this inferior. This list owns a
46 reference to each object it contains. */
47 struct threadlist_entry *threads;
49 /* Number of threads in the list. */
53 static PyTypeObject inferior_object_type
54 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("inferior_object");
56 static const struct inferior_data *infpy_inf_data_key;
62 /* These are kept just for mbpy_str. */
67 static PyTypeObject membuf_object_type
68 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("membuf_object");
70 /* Require that INFERIOR be a valid inferior ID. */
71 #define INFPY_REQUIRE_VALID(Inferior) \
73 if (!Inferior->inferior) \
75 PyErr_SetString (PyExc_RuntimeError, \
76 _("Inferior no longer exists.")); \
82 python_on_normal_stop (struct bpstats *bs, int print_frame)
84 struct cleanup *cleanup;
85 enum gdb_signal stop_signal;
87 if (!gdb_python_initialized)
90 if (!find_thread_ptid (inferior_ptid))
93 stop_signal = inferior_thread ()->suspend.stop_signal;
95 cleanup = ensure_python_env (get_current_arch (), current_language);
97 if (emit_stop_event (bs, stop_signal) < 0)
100 do_cleanups (cleanup);
104 python_on_resume (ptid_t ptid)
106 struct cleanup *cleanup;
108 if (!gdb_python_initialized)
111 cleanup = ensure_python_env (target_gdbarch (), current_language);
113 if (emit_continue_event (ptid) < 0)
114 gdbpy_print_stack ();
116 do_cleanups (cleanup);
119 /* Callback, registered as an observer, that notifies Python listeners
120 when an inferior function call is about to be made. */
123 python_on_inferior_call_pre (ptid_t thread, CORE_ADDR address)
125 struct cleanup *cleanup;
127 cleanup = ensure_python_env (target_gdbarch (), current_language);
129 if (emit_inferior_call_event (INFERIOR_CALL_PRE, thread, address) < 0)
130 gdbpy_print_stack ();
132 do_cleanups (cleanup);
135 /* Callback, registered as an observer, that notifies Python listeners
136 when an inferior function call has completed. */
139 python_on_inferior_call_post (ptid_t thread, CORE_ADDR address)
141 struct cleanup *cleanup;
143 cleanup = ensure_python_env (target_gdbarch (), current_language);
145 if (emit_inferior_call_event (INFERIOR_CALL_POST, thread, address) < 0)
146 gdbpy_print_stack ();
148 do_cleanups (cleanup);
151 /* Callback, registered as an observer, that notifies Python listeners
152 when a part of memory has been modified by user action (eg via a
156 python_on_memory_change (struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
158 struct cleanup *cleanup;
160 cleanup = ensure_python_env (target_gdbarch (), current_language);
162 if (emit_memory_changed_event (addr, len) < 0)
163 gdbpy_print_stack ();
165 do_cleanups (cleanup);
168 /* Callback, registered as an observer, that notifies Python listeners
169 when a register has been modified by user action (eg via a 'set'
173 python_on_register_change (struct frame_info *frame, int regnum)
175 struct cleanup *cleanup;
177 cleanup = ensure_python_env (target_gdbarch (), current_language);
179 if (emit_register_changed_event (frame, regnum) < 0)
180 gdbpy_print_stack ();
182 do_cleanups (cleanup);
186 python_inferior_exit (struct inferior *inf)
188 struct cleanup *cleanup;
189 const LONGEST *exit_code = NULL;
191 if (!gdb_python_initialized)
194 cleanup = ensure_python_env (target_gdbarch (), current_language);
196 if (inf->has_exit_code)
197 exit_code = &inf->exit_code;
199 if (emit_exited_event (exit_code, inf) < 0)
200 gdbpy_print_stack ();
202 do_cleanups (cleanup);
205 /* Callback used to notify Python listeners about new objfiles loaded in the
206 inferior. OBJFILE may be NULL which means that the objfile list has been
207 cleared (emptied). */
210 python_new_objfile (struct objfile *objfile)
212 struct cleanup *cleanup;
214 if (!gdb_python_initialized)
217 cleanup = ensure_python_env (objfile != NULL
218 ? get_objfile_arch (objfile)
224 if (emit_clear_objfiles_event () < 0)
225 gdbpy_print_stack ();
229 if (emit_new_objfile_event (objfile) < 0)
230 gdbpy_print_stack ();
233 do_cleanups (cleanup);
236 /* Return a reference to the Python object of type Inferior
237 representing INFERIOR. If the object has already been created,
238 return it and increment the reference count, otherwise, create it.
239 Return NULL on failure. */
241 inferior_to_inferior_object (struct inferior *inferior)
243 inferior_object *inf_obj;
245 inf_obj = inferior_data (inferior, infpy_inf_data_key);
248 inf_obj = PyObject_New (inferior_object, &inferior_object_type);
252 inf_obj->inferior = inferior;
253 inf_obj->threads = NULL;
254 inf_obj->nthreads = 0;
256 set_inferior_data (inferior, infpy_inf_data_key, inf_obj);
260 Py_INCREF ((PyObject *)inf_obj);
262 return (PyObject *) inf_obj;
265 /* Finds the Python Inferior object for the given PID. Returns a
266 reference, or NULL if PID does not match any inferior object. */
269 find_inferior_object (int pid)
271 struct inferior *inf = find_inferior_pid (pid);
274 return inferior_to_inferior_object (inf);
280 find_thread_object (ptid_t ptid)
283 struct threadlist_entry *thread;
285 thread_object *found = NULL;
287 pid = ptid_get_pid (ptid);
291 inf_obj = find_inferior_object (pid);
296 for (thread = ((inferior_object *)inf_obj)->threads; thread;
297 thread = thread->next)
298 if (ptid_equal (thread->thread_obj->thread->ptid, ptid))
300 found = thread->thread_obj;
313 add_thread_object (struct thread_info *tp)
315 struct cleanup *cleanup;
316 thread_object *thread_obj;
317 inferior_object *inf_obj;
318 struct threadlist_entry *entry;
320 if (!gdb_python_initialized)
323 cleanup = ensure_python_env (python_gdbarch, python_language);
325 thread_obj = create_thread_object (tp);
328 gdbpy_print_stack ();
329 do_cleanups (cleanup);
333 inf_obj = (inferior_object *) thread_obj->inf_obj;
335 entry = xmalloc (sizeof (struct threadlist_entry));
336 entry->thread_obj = thread_obj;
337 entry->next = inf_obj->threads;
339 inf_obj->threads = entry;
342 do_cleanups (cleanup);
346 delete_thread_object (struct thread_info *tp, int ignore)
348 struct cleanup *cleanup;
349 inferior_object *inf_obj;
350 struct threadlist_entry **entry, *tmp;
352 if (!gdb_python_initialized)
355 cleanup = ensure_python_env (python_gdbarch, python_language);
358 = (inferior_object *) find_inferior_object (ptid_get_pid (tp->ptid));
361 do_cleanups (cleanup);
365 /* Find thread entry in its inferior's thread_list. */
366 for (entry = &inf_obj->threads; *entry != NULL; entry =
368 if ((*entry)->thread_obj->thread == tp)
374 do_cleanups (cleanup);
379 tmp->thread_obj->thread = NULL;
381 *entry = (*entry)->next;
384 Py_DECREF (tmp->thread_obj);
388 do_cleanups (cleanup);
392 infpy_threads (PyObject *self, PyObject *args)
395 struct threadlist_entry *entry;
396 inferior_object *inf_obj = (inferior_object *) self;
398 volatile struct gdb_exception except;
400 INFPY_REQUIRE_VALID (inf_obj);
402 TRY_CATCH (except, RETURN_MASK_ALL)
403 update_thread_list ();
404 GDB_PY_HANDLE_EXCEPTION (except);
406 tuple = PyTuple_New (inf_obj->nthreads);
410 for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
411 i++, entry = entry->next)
413 Py_INCREF (entry->thread_obj);
414 PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
421 infpy_get_num (PyObject *self, void *closure)
423 inferior_object *inf = (inferior_object *) self;
425 INFPY_REQUIRE_VALID (inf);
427 return PyLong_FromLong (inf->inferior->num);
431 infpy_get_pid (PyObject *self, void *closure)
433 inferior_object *inf = (inferior_object *) self;
435 INFPY_REQUIRE_VALID (inf);
437 return PyLong_FromLong (inf->inferior->pid);
441 infpy_get_was_attached (PyObject *self, void *closure)
443 inferior_object *inf = (inferior_object *) self;
445 INFPY_REQUIRE_VALID (inf);
446 if (inf->inferior->attach_flag)
452 build_inferior_list (struct inferior *inf, void *arg)
454 PyObject *list = arg;
455 PyObject *inferior = inferior_to_inferior_object (inf);
461 success = PyList_Append (list, inferior);
462 Py_DECREF (inferior);
470 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
471 Returns a tuple of all inferiors. */
473 gdbpy_inferiors (PyObject *unused, PyObject *unused2)
475 PyObject *list, *tuple;
477 list = PyList_New (0);
481 if (iterate_over_inferiors (build_inferior_list, list))
487 tuple = PyList_AsTuple (list);
493 /* Membuf and memory manipulation. */
495 /* Implementation of Inferior.read_memory (address, length).
496 Returns a Python buffer object with LENGTH bytes of the inferior's
497 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
498 with a python exception set. */
500 infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
502 CORE_ADDR addr, length;
504 membuf_object *membuf_obj;
505 PyObject *addr_obj, *length_obj, *result;
506 volatile struct gdb_exception except;
507 static char *keywords[] = { "address", "length", NULL };
509 if (! PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
510 &addr_obj, &length_obj))
513 if (get_addr_from_python (addr_obj, &addr) < 0
514 || get_addr_from_python (length_obj, &length) < 0)
517 TRY_CATCH (except, RETURN_MASK_ALL)
519 buffer = xmalloc (length);
521 read_memory (addr, buffer, length);
523 if (except.reason < 0)
526 GDB_PY_HANDLE_EXCEPTION (except);
529 membuf_obj = PyObject_New (membuf_object, &membuf_object_type);
530 if (membuf_obj == NULL)
536 membuf_obj->buffer = buffer;
537 membuf_obj->addr = addr;
538 membuf_obj->length = length;
541 result = PyMemoryView_FromObject ((PyObject *) membuf_obj);
543 result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj, 0,
546 Py_DECREF (membuf_obj);
551 /* Implementation of Inferior.write_memory (address, buffer [, length]).
552 Writes the contents of BUFFER (a Python object supporting the read
553 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
554 bytes from BUFFER, or its entire contents if the argument is not
555 provided. The function returns nothing. Returns NULL on error, with
556 a python exception set. */
558 infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
562 CORE_ADDR addr, length;
563 PyObject *addr_obj, *length_obj = NULL;
564 volatile struct gdb_exception except;
565 static char *keywords[] = { "address", "buffer", "length", NULL };
569 if (! PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
577 if (! PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
578 &addr_obj, &buffer, &buf_len,
583 if (get_addr_from_python (addr_obj, &addr) < 0)
588 else if (get_addr_from_python (length_obj, &length) < 0)
591 TRY_CATCH (except, RETURN_MASK_ALL)
593 write_memory_with_notification (addr, (gdb_byte *) buffer, length);
596 PyBuffer_Release (&pybuf);
598 GDB_PY_HANDLE_EXCEPTION (except);
604 PyBuffer_Release (&pybuf);
609 /* Destructor of Membuf objects. */
611 mbpy_dealloc (PyObject *self)
613 xfree (((membuf_object *) self)->buffer);
614 Py_TYPE (self)->tp_free (self);
617 /* Return a description of the Membuf object. */
619 mbpy_str (PyObject *self)
621 membuf_object *membuf_obj = (membuf_object *) self;
623 return PyString_FromFormat (_("Memory buffer for address %s, \
624 which is %s bytes long."),
625 paddress (python_gdbarch, membuf_obj->addr),
626 pulongest (membuf_obj->length));
632 get_buffer (PyObject *self, Py_buffer *buf, int flags)
634 membuf_object *membuf_obj = (membuf_object *) self;
637 ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
638 membuf_obj->length, 0,
648 get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
650 membuf_object *membuf_obj = (membuf_object *) self;
654 PyErr_SetString (PyExc_SystemError,
655 _("The memory buffer supports only one segment."));
659 *ptrptr = membuf_obj->buffer;
661 return membuf_obj->length;
665 get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
667 return get_read_buffer (self, segment, ptrptr);
671 get_seg_count (PyObject *self, Py_ssize_t *lenp)
674 *lenp = ((membuf_object *) self)->length;
680 get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
685 ret = get_read_buffer (self, segment, &ptr);
686 *ptrptr = (char *) ptr;
694 gdb.search_memory (address, length, pattern). ADDRESS is the
695 address to start the search. LENGTH specifies the scope of the
696 search from ADDRESS. PATTERN is the pattern to search for (and
697 must be a Python object supporting the buffer protocol).
698 Returns a Python Long object holding the address where the pattern
699 was located, or if the pattern was not found, returns None. Returns NULL
700 on error, with a python exception set. */
702 infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
704 CORE_ADDR start_addr, length;
705 static char *keywords[] = { "address", "length", "pattern", NULL };
706 PyObject *start_addr_obj, *length_obj;
707 volatile struct gdb_exception except;
708 Py_ssize_t pattern_size;
710 CORE_ADDR found_addr;
715 if (! PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
716 &start_addr_obj, &length_obj,
721 pattern_size = pybuf.len;
725 if (! PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
726 &start_addr_obj, &length_obj,
730 if (!PyObject_CheckReadBuffer (pattern))
732 PyErr_SetString (PyExc_RuntimeError,
733 _("The pattern is not a Python buffer."));
738 if (PyObject_AsReadBuffer (pattern, &buffer, &pattern_size) == -1)
742 if (get_addr_from_python (start_addr_obj, &start_addr) < 0)
745 if (get_addr_from_python (length_obj, &length) < 0)
750 PyErr_SetString (PyExc_ValueError,
751 _("Search range is empty."));
754 /* Watch for overflows. */
755 else if (length > CORE_ADDR_MAX
756 || (start_addr + length - 1) < start_addr)
758 PyErr_SetString (PyExc_ValueError,
759 _("The search range is too large."));
763 TRY_CATCH (except, RETURN_MASK_ALL)
765 found = target_search_memory (start_addr, length,
766 buffer, pattern_size,
770 PyBuffer_Release (&pybuf);
772 GDB_PY_HANDLE_EXCEPTION (except);
775 return PyLong_FromLong (found_addr);
781 PyBuffer_Release (&pybuf);
786 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
787 Returns True if this inferior object still exists in GDB. */
790 infpy_is_valid (PyObject *self, PyObject *args)
792 inferior_object *inf = (inferior_object *) self;
801 infpy_dealloc (PyObject *obj)
803 inferior_object *inf_obj = (inferior_object *) obj;
804 struct inferior *inf = inf_obj->inferior;
809 set_inferior_data (inf, infpy_inf_data_key, NULL);
812 /* Clear the INFERIOR pointer in an Inferior object and clear the
815 py_free_inferior (struct inferior *inf, void *datum)
818 struct cleanup *cleanup;
819 inferior_object *inf_obj = datum;
820 struct threadlist_entry *th_entry, *th_tmp;
822 if (!gdb_python_initialized)
825 cleanup = ensure_python_env (python_gdbarch, python_language);
827 inf_obj->inferior = NULL;
829 /* Deallocate threads list. */
830 for (th_entry = inf_obj->threads; th_entry != NULL;)
832 Py_DECREF (th_entry->thread_obj);
835 th_entry = th_entry->next;
839 inf_obj->nthreads = 0;
841 Py_DECREF ((PyObject *) inf_obj);
842 do_cleanups (cleanup);
845 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
846 Returns the current inferior object. */
849 gdbpy_selected_inferior (PyObject *self, PyObject *args)
851 return inferior_to_inferior_object (current_inferior ());
855 gdbpy_initialize_inferior (void)
857 if (PyType_Ready (&inferior_object_type) < 0)
860 if (gdb_pymodule_addobject (gdb_module, "Inferior",
861 (PyObject *) &inferior_object_type) < 0)
865 register_inferior_data_with_cleanup (NULL, py_free_inferior);
867 observer_attach_new_thread (add_thread_object);
868 observer_attach_thread_exit (delete_thread_object);
869 observer_attach_normal_stop (python_on_normal_stop);
870 observer_attach_target_resumed (python_on_resume);
871 observer_attach_inferior_call_pre (python_on_inferior_call_pre);
872 observer_attach_inferior_call_post (python_on_inferior_call_post);
873 observer_attach_memory_changed (python_on_memory_change);
874 observer_attach_register_changed (python_on_register_change);
875 observer_attach_inferior_exit (python_inferior_exit);
876 observer_attach_new_objfile (python_new_objfile);
878 membuf_object_type.tp_new = PyType_GenericNew;
879 if (PyType_Ready (&membuf_object_type) < 0)
882 return gdb_pymodule_addobject (gdb_module, "Membuf", (PyObject *)
883 &membuf_object_type);
886 static PyGetSetDef inferior_object_getset[] =
888 { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
889 { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
891 { "was_attached", infpy_get_was_attached, NULL,
892 "True if the inferior was created using 'attach'.", NULL },
896 static PyMethodDef inferior_object_methods[] =
898 { "is_valid", infpy_is_valid, METH_NOARGS,
899 "is_valid () -> Boolean.\n\
900 Return true if this inferior is valid, false if not." },
901 { "threads", infpy_threads, METH_NOARGS,
902 "Return all the threads of this inferior." },
903 { "read_memory", (PyCFunction) infpy_read_memory,
904 METH_VARARGS | METH_KEYWORDS,
905 "read_memory (address, length) -> buffer\n\
906 Return a buffer object for reading from the inferior's memory." },
907 { "write_memory", (PyCFunction) infpy_write_memory,
908 METH_VARARGS | METH_KEYWORDS,
909 "write_memory (address, buffer [, length])\n\
910 Write the given buffer object to the inferior's memory." },
911 { "search_memory", (PyCFunction) infpy_search_memory,
912 METH_VARARGS | METH_KEYWORDS,
913 "search_memory (address, length, pattern) -> long\n\
914 Return a long with the address of a match, or None." },
918 static PyTypeObject inferior_object_type =
920 PyVarObject_HEAD_INIT (NULL, 0)
921 "gdb.Inferior", /* tp_name */
922 sizeof (inferior_object), /* tp_basicsize */
924 infpy_dealloc, /* tp_dealloc */
930 0, /* tp_as_number */
931 0, /* tp_as_sequence */
932 0, /* tp_as_mapping */
938 0, /* tp_as_buffer */
939 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /* tp_flags */
940 "GDB inferior object", /* tp_doc */
943 0, /* tp_richcompare */
944 0, /* tp_weaklistoffset */
947 inferior_object_methods, /* tp_methods */
949 inferior_object_getset, /* tp_getset */
952 0, /* tp_descr_get */
953 0, /* tp_descr_set */
954 0, /* tp_dictoffset */
961 static PyBufferProcs buffer_procs =
968 /* Python doesn't provide a decent way to get compatibility here. */
969 #if HAVE_LIBPYTHON2_4
970 #define CHARBUFFERPROC_NAME getcharbufferproc
972 #define CHARBUFFERPROC_NAME charbufferproc
975 static PyBufferProcs buffer_procs = {
979 /* The cast here works around a difference between Python 2.4 and
981 (CHARBUFFERPROC_NAME) get_char_buffer
985 static PyTypeObject membuf_object_type = {
986 PyVarObject_HEAD_INIT (NULL, 0)
987 "gdb.Membuf", /*tp_name*/
988 sizeof (membuf_object), /*tp_basicsize*/
990 mbpy_dealloc, /*tp_dealloc*/
997 0, /*tp_as_sequence*/
1001 mbpy_str, /*tp_str*/
1004 &buffer_procs, /*tp_as_buffer*/
1005 Py_TPFLAGS_DEFAULT, /*tp_flags*/
1006 "GDB memory buffer object", /*tp_doc*/
1007 0, /* tp_traverse */
1009 0, /* tp_richcompare */
1010 0, /* tp_weaklistoffset */
1012 0, /* tp_iternext */
1018 0, /* tp_descr_get */
1019 0, /* tp_descr_set */
1020 0, /* tp_dictoffset */