1 /* Python interface to inferiors.
3 Copyright (C) 2009-2017 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 extern 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 extern 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 enum gdb_signal stop_signal
;
86 if (!gdb_python_initialized
)
89 if (!find_thread_ptid (inferior_ptid
))
92 stop_signal
= inferior_thread ()->suspend
.stop_signal
;
94 gdbpy_enter
enter_py (get_current_arch (), current_language
);
96 if (emit_stop_event (bs
, stop_signal
) < 0)
101 python_on_resume (ptid_t ptid
)
103 if (!gdb_python_initialized
)
106 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
108 if (emit_continue_event (ptid
) < 0)
109 gdbpy_print_stack ();
112 /* Callback, registered as an observer, that notifies Python listeners
113 when an inferior function call is about to be made. */
116 python_on_inferior_call_pre (ptid_t thread
, CORE_ADDR address
)
118 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
120 if (emit_inferior_call_event (INFERIOR_CALL_PRE
, thread
, address
) < 0)
121 gdbpy_print_stack ();
124 /* Callback, registered as an observer, that notifies Python listeners
125 when an inferior function call has completed. */
128 python_on_inferior_call_post (ptid_t thread
, CORE_ADDR address
)
130 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
132 if (emit_inferior_call_event (INFERIOR_CALL_POST
, thread
, address
) < 0)
133 gdbpy_print_stack ();
136 /* Callback, registered as an observer, that notifies Python listeners
137 when a part of memory has been modified by user action (eg via a
141 python_on_memory_change (struct inferior
*inferior
, CORE_ADDR addr
, ssize_t len
, const bfd_byte
*data
)
143 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
145 if (emit_memory_changed_event (addr
, len
) < 0)
146 gdbpy_print_stack ();
149 /* Callback, registered as an observer, that notifies Python listeners
150 when a register has been modified by user action (eg via a 'set'
154 python_on_register_change (struct frame_info
*frame
, int regnum
)
156 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
158 if (emit_register_changed_event (frame
, regnum
) < 0)
159 gdbpy_print_stack ();
163 python_inferior_exit (struct inferior
*inf
)
165 const LONGEST
*exit_code
= NULL
;
167 if (!gdb_python_initialized
)
170 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
172 if (inf
->has_exit_code
)
173 exit_code
= &inf
->exit_code
;
175 if (emit_exited_event (exit_code
, inf
) < 0)
176 gdbpy_print_stack ();
179 /* Callback used to notify Python listeners about new objfiles loaded in the
180 inferior. OBJFILE may be NULL which means that the objfile list has been
181 cleared (emptied). */
184 python_new_objfile (struct objfile
*objfile
)
186 if (!gdb_python_initialized
)
189 gdbpy_enter
enter_py (objfile
!= NULL
190 ? get_objfile_arch (objfile
)
196 if (emit_clear_objfiles_event () < 0)
197 gdbpy_print_stack ();
201 if (emit_new_objfile_event (objfile
) < 0)
202 gdbpy_print_stack ();
206 /* Return a reference to the Python object of type Inferior
207 representing INFERIOR. If the object has already been created,
208 return it and increment the reference count, otherwise, create it.
209 Return NULL on failure. */
211 inferior_to_inferior_object (struct inferior
*inferior
)
213 inferior_object
*inf_obj
;
215 inf_obj
= (inferior_object
*) inferior_data (inferior
, infpy_inf_data_key
);
218 inf_obj
= PyObject_New (inferior_object
, &inferior_object_type
);
222 inf_obj
->inferior
= inferior
;
223 inf_obj
->threads
= NULL
;
224 inf_obj
->nthreads
= 0;
226 set_inferior_data (inferior
, infpy_inf_data_key
, inf_obj
);
230 Py_INCREF ((PyObject
*)inf_obj
);
232 return (PyObject
*) inf_obj
;
235 /* Finds the Python Inferior object for the given PID. Returns a
236 reference, or NULL if PID does not match any inferior object. */
239 find_inferior_object (int pid
)
241 struct inferior
*inf
= find_inferior_pid (pid
);
244 return inferior_to_inferior_object (inf
);
250 find_thread_object (ptid_t ptid
)
253 struct threadlist_entry
*thread
;
255 pid
= ptid_get_pid (ptid
);
259 gdbpy_ref
<> inf_obj (find_inferior_object (pid
));
263 for (thread
= ((inferior_object
*)(inf_obj
.get ()))->threads
; thread
;
264 thread
= thread
->next
)
265 if (ptid_equal (thread
->thread_obj
->thread
->ptid
, ptid
))
266 return thread
->thread_obj
;
272 add_thread_object (struct thread_info
*tp
)
274 thread_object
*thread_obj
;
275 inferior_object
*inf_obj
;
276 struct threadlist_entry
*entry
;
278 if (!gdb_python_initialized
)
281 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
283 thread_obj
= create_thread_object (tp
);
286 gdbpy_print_stack ();
290 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
292 entry
= XNEW (struct threadlist_entry
);
293 entry
->thread_obj
= thread_obj
;
294 entry
->next
= inf_obj
->threads
;
296 inf_obj
->threads
= entry
;
301 delete_thread_object (struct thread_info
*tp
, int ignore
)
303 struct threadlist_entry
**entry
, *tmp
;
305 if (!gdb_python_initialized
)
308 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
310 gdbpy_ref
<inferior_object
> inf_obj
311 ((inferior_object
*) find_inferior_object (ptid_get_pid (tp
->ptid
)));
315 /* Find thread entry in its inferior's thread_list. */
316 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
318 if ((*entry
)->thread_obj
->thread
== tp
)
325 tmp
->thread_obj
->thread
= NULL
;
327 *entry
= (*entry
)->next
;
330 Py_DECREF (tmp
->thread_obj
);
335 infpy_threads (PyObject
*self
, PyObject
*args
)
338 struct threadlist_entry
*entry
;
339 inferior_object
*inf_obj
= (inferior_object
*) self
;
342 INFPY_REQUIRE_VALID (inf_obj
);
346 update_thread_list ();
348 CATCH (except
, RETURN_MASK_ALL
)
350 GDB_PY_HANDLE_EXCEPTION (except
);
354 tuple
= PyTuple_New (inf_obj
->nthreads
);
358 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
359 i
++, entry
= entry
->next
)
361 Py_INCREF (entry
->thread_obj
);
362 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
369 infpy_get_num (PyObject
*self
, void *closure
)
371 inferior_object
*inf
= (inferior_object
*) self
;
373 INFPY_REQUIRE_VALID (inf
);
375 return PyLong_FromLong (inf
->inferior
->num
);
379 infpy_get_pid (PyObject
*self
, void *closure
)
381 inferior_object
*inf
= (inferior_object
*) self
;
383 INFPY_REQUIRE_VALID (inf
);
385 return PyLong_FromLong (inf
->inferior
->pid
);
389 infpy_get_was_attached (PyObject
*self
, void *closure
)
391 inferior_object
*inf
= (inferior_object
*) self
;
393 INFPY_REQUIRE_VALID (inf
);
394 if (inf
->inferior
->attach_flag
)
400 build_inferior_list (struct inferior
*inf
, void *arg
)
402 PyObject
*list
= (PyObject
*) arg
;
403 gdbpy_ref
<> inferior (inferior_to_inferior_object (inf
));
405 if (inferior
== NULL
)
408 return PyList_Append (list
, inferior
.get ()) ? 1 : 0;
411 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
412 Returns a tuple of all inferiors. */
414 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
416 gdbpy_ref
<> list (PyList_New (0));
420 if (iterate_over_inferiors (build_inferior_list
, list
.get ()))
423 return PyList_AsTuple (list
.get ());
426 /* Membuf and memory manipulation. */
428 /* Implementation of Inferior.read_memory (address, length).
429 Returns a Python buffer object with LENGTH bytes of the inferior's
430 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
431 with a python exception set. */
433 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
435 CORE_ADDR addr
, length
;
436 gdb_byte
*buffer
= NULL
;
437 PyObject
*addr_obj
, *length_obj
, *result
;
438 static char *keywords
[] = { "address", "length", NULL
};
440 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
441 &addr_obj
, &length_obj
))
444 if (get_addr_from_python (addr_obj
, &addr
) < 0
445 || get_addr_from_python (length_obj
, &length
) < 0)
450 buffer
= (gdb_byte
*) xmalloc (length
);
452 read_memory (addr
, buffer
, length
);
454 CATCH (except
, RETURN_MASK_ALL
)
457 GDB_PY_HANDLE_EXCEPTION (except
);
461 gdbpy_ref
<membuf_object
> membuf_obj (PyObject_New (membuf_object
,
462 &membuf_object_type
));
463 if (membuf_obj
== NULL
)
469 membuf_obj
->buffer
= buffer
;
470 membuf_obj
->addr
= addr
;
471 membuf_obj
->length
= length
;
474 result
= PyMemoryView_FromObject ((PyObject
*) membuf_obj
.get ());
476 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
.get (), 0,
483 /* Implementation of Inferior.write_memory (address, buffer [, length]).
484 Writes the contents of BUFFER (a Python object supporting the read
485 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
486 bytes from BUFFER, or its entire contents if the argument is not
487 provided. The function returns nothing. Returns NULL on error, with
488 a python exception set. */
490 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
492 struct gdb_exception except
= exception_none
;
494 const gdb_byte
*buffer
;
495 CORE_ADDR addr
, length
;
496 PyObject
*addr_obj
, *length_obj
= NULL
;
497 static char *keywords
[] = { "address", "buffer", "length", NULL
};
501 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os*|O", keywords
,
506 buffer
= (const gdb_byte
*) pybuf
.buf
;
509 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os#|O", keywords
,
510 &addr_obj
, &buffer
, &buf_len
,
514 buffer
= (const gdb_byte
*) buffer
;
517 if (get_addr_from_python (addr_obj
, &addr
) < 0)
522 else if (get_addr_from_python (length_obj
, &length
) < 0)
527 write_memory_with_notification (addr
, buffer
, length
);
529 CATCH (ex
, RETURN_MASK_ALL
)
536 PyBuffer_Release (&pybuf
);
538 GDB_PY_HANDLE_EXCEPTION (except
);
544 PyBuffer_Release (&pybuf
);
549 /* Destructor of Membuf objects. */
551 mbpy_dealloc (PyObject
*self
)
553 xfree (((membuf_object
*) self
)->buffer
);
554 Py_TYPE (self
)->tp_free (self
);
557 /* Return a description of the Membuf object. */
559 mbpy_str (PyObject
*self
)
561 membuf_object
*membuf_obj
= (membuf_object
*) self
;
563 return PyString_FromFormat (_("Memory buffer for address %s, \
564 which is %s bytes long."),
565 paddress (python_gdbarch
, membuf_obj
->addr
),
566 pulongest (membuf_obj
->length
));
572 get_buffer (PyObject
*self
, Py_buffer
*buf
, int flags
)
574 membuf_object
*membuf_obj
= (membuf_object
*) self
;
577 ret
= PyBuffer_FillInfo (buf
, self
, membuf_obj
->buffer
,
578 membuf_obj
->length
, 0,
588 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
590 membuf_object
*membuf_obj
= (membuf_object
*) self
;
594 PyErr_SetString (PyExc_SystemError
,
595 _("The memory buffer supports only one segment."));
599 *ptrptr
= membuf_obj
->buffer
;
601 return membuf_obj
->length
;
605 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
607 return get_read_buffer (self
, segment
, ptrptr
);
611 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
614 *lenp
= ((membuf_object
*) self
)->length
;
620 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
625 ret
= get_read_buffer (self
, segment
, &ptr
);
626 *ptrptr
= (char *) ptr
;
634 gdb.search_memory (address, length, pattern). ADDRESS is the
635 address to start the search. LENGTH specifies the scope of the
636 search from ADDRESS. PATTERN is the pattern to search for (and
637 must be a Python object supporting the buffer protocol).
638 Returns a Python Long object holding the address where the pattern
639 was located, or if the pattern was not found, returns None. Returns NULL
640 on error, with a python exception set. */
642 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
644 struct gdb_exception except
= exception_none
;
645 CORE_ADDR start_addr
, length
;
646 static char *keywords
[] = { "address", "length", "pattern", NULL
};
647 PyObject
*start_addr_obj
, *length_obj
;
648 Py_ssize_t pattern_size
;
649 const gdb_byte
*buffer
;
650 CORE_ADDR found_addr
;
655 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOs*", keywords
,
656 &start_addr_obj
, &length_obj
,
660 buffer
= (const gdb_byte
*) pybuf
.buf
;
661 pattern_size
= pybuf
.len
;
666 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOO", keywords
,
667 &start_addr_obj
, &length_obj
,
671 if (!PyObject_CheckReadBuffer (pattern
))
673 PyErr_SetString (PyExc_RuntimeError
,
674 _("The pattern is not a Python buffer."));
679 if (PyObject_AsReadBuffer (pattern
, &vbuffer
, &pattern_size
) == -1)
682 buffer
= (const gdb_byte
*) vbuffer
;
685 if (get_addr_from_python (start_addr_obj
, &start_addr
) < 0)
688 if (get_addr_from_python (length_obj
, &length
) < 0)
693 PyErr_SetString (PyExc_ValueError
,
694 _("Search range is empty."));
697 /* Watch for overflows. */
698 else if (length
> CORE_ADDR_MAX
699 || (start_addr
+ length
- 1) < start_addr
)
701 PyErr_SetString (PyExc_ValueError
,
702 _("The search range is too large."));
708 found
= target_search_memory (start_addr
, length
,
709 buffer
, pattern_size
,
712 CATCH (ex
, RETURN_MASK_ALL
)
719 PyBuffer_Release (&pybuf
);
721 GDB_PY_HANDLE_EXCEPTION (except
);
724 return PyLong_FromLong (found_addr
);
730 PyBuffer_Release (&pybuf
);
735 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
736 Returns True if this inferior object still exists in GDB. */
739 infpy_is_valid (PyObject
*self
, PyObject
*args
)
741 inferior_object
*inf
= (inferior_object
*) self
;
750 infpy_dealloc (PyObject
*obj
)
752 inferior_object
*inf_obj
= (inferior_object
*) obj
;
753 struct inferior
*inf
= inf_obj
->inferior
;
758 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
761 /* Clear the INFERIOR pointer in an Inferior object and clear the
764 py_free_inferior (struct inferior
*inf
, void *datum
)
766 gdbpy_ref
<inferior_object
> inf_obj ((inferior_object
*) datum
);
767 struct threadlist_entry
*th_entry
, *th_tmp
;
769 if (!gdb_python_initialized
)
772 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
774 inf_obj
->inferior
= NULL
;
776 /* Deallocate threads list. */
777 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
779 Py_DECREF (th_entry
->thread_obj
);
782 th_entry
= th_entry
->next
;
786 inf_obj
->nthreads
= 0;
789 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
790 Returns the current inferior object. */
793 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
795 return inferior_to_inferior_object (current_inferior ());
799 gdbpy_initialize_inferior (void)
801 if (PyType_Ready (&inferior_object_type
) < 0)
804 if (gdb_pymodule_addobject (gdb_module
, "Inferior",
805 (PyObject
*) &inferior_object_type
) < 0)
809 register_inferior_data_with_cleanup (NULL
, py_free_inferior
);
811 observer_attach_new_thread (add_thread_object
);
812 observer_attach_thread_exit (delete_thread_object
);
813 observer_attach_normal_stop (python_on_normal_stop
);
814 observer_attach_target_resumed (python_on_resume
);
815 observer_attach_inferior_call_pre (python_on_inferior_call_pre
);
816 observer_attach_inferior_call_post (python_on_inferior_call_post
);
817 observer_attach_memory_changed (python_on_memory_change
);
818 observer_attach_register_changed (python_on_register_change
);
819 observer_attach_inferior_exit (python_inferior_exit
);
820 observer_attach_new_objfile (python_new_objfile
);
822 membuf_object_type
.tp_new
= PyType_GenericNew
;
823 if (PyType_Ready (&membuf_object_type
) < 0)
826 return gdb_pymodule_addobject (gdb_module
, "Membuf", (PyObject
*)
827 &membuf_object_type
);
830 static PyGetSetDef inferior_object_getset
[] =
832 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
833 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
835 { "was_attached", infpy_get_was_attached
, NULL
,
836 "True if the inferior was created using 'attach'.", NULL
},
840 static PyMethodDef inferior_object_methods
[] =
842 { "is_valid", infpy_is_valid
, METH_NOARGS
,
843 "is_valid () -> Boolean.\n\
844 Return true if this inferior is valid, false if not." },
845 { "threads", infpy_threads
, METH_NOARGS
,
846 "Return all the threads of this inferior." },
847 { "read_memory", (PyCFunction
) infpy_read_memory
,
848 METH_VARARGS
| METH_KEYWORDS
,
849 "read_memory (address, length) -> buffer\n\
850 Return a buffer object for reading from the inferior's memory." },
851 { "write_memory", (PyCFunction
) infpy_write_memory
,
852 METH_VARARGS
| METH_KEYWORDS
,
853 "write_memory (address, buffer [, length])\n\
854 Write the given buffer object to the inferior's memory." },
855 { "search_memory", (PyCFunction
) infpy_search_memory
,
856 METH_VARARGS
| METH_KEYWORDS
,
857 "search_memory (address, length, pattern) -> long\n\
858 Return a long with the address of a match, or None." },
862 PyTypeObject inferior_object_type
=
864 PyVarObject_HEAD_INIT (NULL
, 0)
865 "gdb.Inferior", /* tp_name */
866 sizeof (inferior_object
), /* tp_basicsize */
868 infpy_dealloc
, /* tp_dealloc */
874 0, /* tp_as_number */
875 0, /* tp_as_sequence */
876 0, /* tp_as_mapping */
882 0, /* tp_as_buffer */
883 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
884 "GDB inferior object", /* tp_doc */
887 0, /* tp_richcompare */
888 0, /* tp_weaklistoffset */
891 inferior_object_methods
, /* tp_methods */
893 inferior_object_getset
, /* tp_getset */
896 0, /* tp_descr_get */
897 0, /* tp_descr_set */
898 0, /* tp_dictoffset */
905 static PyBufferProcs buffer_procs
=
912 /* Python doesn't provide a decent way to get compatibility here. */
913 #if HAVE_LIBPYTHON2_4
914 #define CHARBUFFERPROC_NAME getcharbufferproc
916 #define CHARBUFFERPROC_NAME charbufferproc
919 static PyBufferProcs buffer_procs
= {
923 /* The cast here works around a difference between Python 2.4 and
925 (CHARBUFFERPROC_NAME
) get_char_buffer
929 PyTypeObject membuf_object_type
= {
930 PyVarObject_HEAD_INIT (NULL
, 0)
931 "gdb.Membuf", /*tp_name*/
932 sizeof (membuf_object
), /*tp_basicsize*/
934 mbpy_dealloc
, /*tp_dealloc*/
941 0, /*tp_as_sequence*/
948 &buffer_procs
, /*tp_as_buffer*/
949 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
950 "GDB memory buffer object", /*tp_doc*/
953 0, /* tp_richcompare */
954 0, /* tp_weaklistoffset */
962 0, /* tp_descr_get */
963 0, /* tp_descr_set */
964 0, /* tp_dictoffset */