1 /* Python interface to inferiors.
3 Copyright (C) 2009-2013 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/>. */
21 #include "exceptions.h"
23 #include "gdbthread.h"
27 #include "python-internal.h"
28 #include "arch-utils.h"
30 #include "gdb_signals.h"
32 #include "py-stopevent.h"
34 struct threadlist_entry
{
35 thread_object
*thread_obj
;
36 struct threadlist_entry
*next
;
43 /* The inferior we represent. */
44 struct inferior
*inferior
;
46 /* thread_object instances under this inferior. This list owns a
47 reference to each object it contains. */
48 struct threadlist_entry
*threads
;
50 /* Number of threads in the list. */
54 static PyTypeObject inferior_object_type
55 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("inferior_object");
57 static const struct inferior_data
*infpy_inf_data_key
;
63 /* These are kept just for mbpy_str. */
68 static PyTypeObject membuf_object_type
69 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("membuf_object");
71 /* Require that INFERIOR be a valid inferior ID. */
72 #define INFPY_REQUIRE_VALID(Inferior) \
74 if (!Inferior->inferior) \
76 PyErr_SetString (PyExc_RuntimeError, \
77 _("Inferior no longer exists.")); \
83 python_on_normal_stop (struct bpstats
*bs
, int print_frame
)
85 struct cleanup
*cleanup
;
86 enum gdb_signal stop_signal
;
88 if (!gdb_python_initialized
)
91 if (!find_thread_ptid (inferior_ptid
))
94 stop_signal
= inferior_thread ()->suspend
.stop_signal
;
96 cleanup
= ensure_python_env (get_current_arch (), current_language
);
98 if (emit_stop_event (bs
, stop_signal
) < 0)
101 do_cleanups (cleanup
);
105 python_on_resume (ptid_t ptid
)
107 struct cleanup
*cleanup
;
109 if (!gdb_python_initialized
)
112 cleanup
= ensure_python_env (target_gdbarch (), current_language
);
114 if (emit_continue_event (ptid
) < 0)
115 gdbpy_print_stack ();
117 do_cleanups (cleanup
);
121 python_inferior_exit (struct inferior
*inf
)
123 struct cleanup
*cleanup
;
124 const LONGEST
*exit_code
= NULL
;
126 if (!gdb_python_initialized
)
129 cleanup
= ensure_python_env (target_gdbarch (), current_language
);
131 if (inf
->has_exit_code
)
132 exit_code
= &inf
->exit_code
;
134 if (emit_exited_event (exit_code
, inf
) < 0)
135 gdbpy_print_stack ();
137 do_cleanups (cleanup
);
140 /* Callback used to notify Python listeners about new objfiles loaded in the
144 python_new_objfile (struct objfile
*objfile
)
146 struct cleanup
*cleanup
;
151 if (!gdb_python_initialized
)
154 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
156 if (emit_new_objfile_event (objfile
) < 0)
157 gdbpy_print_stack ();
159 do_cleanups (cleanup
);
162 /* Return a reference to the Python object of type Inferior
163 representing INFERIOR. If the object has already been created,
164 return it and increment the reference count, otherwise, create it.
165 Return NULL on failure. */
167 inferior_to_inferior_object (struct inferior
*inferior
)
169 inferior_object
*inf_obj
;
171 inf_obj
= inferior_data (inferior
, infpy_inf_data_key
);
174 inf_obj
= PyObject_New (inferior_object
, &inferior_object_type
);
178 inf_obj
->inferior
= inferior
;
179 inf_obj
->threads
= NULL
;
180 inf_obj
->nthreads
= 0;
182 set_inferior_data (inferior
, infpy_inf_data_key
, inf_obj
);
186 Py_INCREF ((PyObject
*)inf_obj
);
188 return (PyObject
*) inf_obj
;
191 /* Finds the Python Inferior object for the given PID. Returns a
192 reference, or NULL if PID does not match any inferior object. */
195 find_inferior_object (int pid
)
197 struct inferior
*inf
= find_inferior_pid (pid
);
200 return inferior_to_inferior_object (inf
);
206 find_thread_object (ptid_t ptid
)
209 struct threadlist_entry
*thread
;
211 thread_object
*found
= NULL
;
217 inf_obj
= find_inferior_object (pid
);
222 for (thread
= ((inferior_object
*)inf_obj
)->threads
; thread
;
223 thread
= thread
->next
)
224 if (ptid_equal (thread
->thread_obj
->thread
->ptid
, ptid
))
226 found
= thread
->thread_obj
;
239 add_thread_object (struct thread_info
*tp
)
241 struct cleanup
*cleanup
;
242 thread_object
*thread_obj
;
243 inferior_object
*inf_obj
;
244 struct threadlist_entry
*entry
;
246 if (!gdb_python_initialized
)
249 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
251 thread_obj
= create_thread_object (tp
);
254 gdbpy_print_stack ();
255 do_cleanups (cleanup
);
259 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
261 entry
= xmalloc (sizeof (struct threadlist_entry
));
262 entry
->thread_obj
= thread_obj
;
263 entry
->next
= inf_obj
->threads
;
265 inf_obj
->threads
= entry
;
268 do_cleanups (cleanup
);
272 delete_thread_object (struct thread_info
*tp
, int ignore
)
274 struct cleanup
*cleanup
;
275 inferior_object
*inf_obj
;
276 struct threadlist_entry
**entry
, *tmp
;
278 if (!gdb_python_initialized
)
281 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
283 inf_obj
= (inferior_object
*) find_inferior_object (PIDGET(tp
->ptid
));
286 do_cleanups (cleanup
);
290 /* Find thread entry in its inferior's thread_list. */
291 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
293 if ((*entry
)->thread_obj
->thread
== tp
)
299 do_cleanups (cleanup
);
304 tmp
->thread_obj
->thread
= NULL
;
306 *entry
= (*entry
)->next
;
309 Py_DECREF (tmp
->thread_obj
);
313 do_cleanups (cleanup
);
317 infpy_threads (PyObject
*self
, PyObject
*args
)
320 struct threadlist_entry
*entry
;
321 inferior_object
*inf_obj
= (inferior_object
*) self
;
323 volatile struct gdb_exception except
;
325 INFPY_REQUIRE_VALID (inf_obj
);
327 TRY_CATCH (except
, RETURN_MASK_ALL
)
328 update_thread_list ();
329 GDB_PY_HANDLE_EXCEPTION (except
);
331 tuple
= PyTuple_New (inf_obj
->nthreads
);
335 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
336 i
++, entry
= entry
->next
)
338 Py_INCREF (entry
->thread_obj
);
339 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
346 infpy_get_num (PyObject
*self
, void *closure
)
348 inferior_object
*inf
= (inferior_object
*) self
;
350 INFPY_REQUIRE_VALID (inf
);
352 return PyLong_FromLong (inf
->inferior
->num
);
356 infpy_get_pid (PyObject
*self
, void *closure
)
358 inferior_object
*inf
= (inferior_object
*) self
;
360 INFPY_REQUIRE_VALID (inf
);
362 return PyLong_FromLong (inf
->inferior
->pid
);
366 infpy_get_was_attached (PyObject
*self
, void *closure
)
368 inferior_object
*inf
= (inferior_object
*) self
;
370 INFPY_REQUIRE_VALID (inf
);
371 if (inf
->inferior
->attach_flag
)
377 build_inferior_list (struct inferior
*inf
, void *arg
)
379 PyObject
*list
= arg
;
380 PyObject
*inferior
= inferior_to_inferior_object (inf
);
386 success
= PyList_Append (list
, inferior
);
387 Py_DECREF (inferior
);
395 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
396 Returns a tuple of all inferiors. */
398 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
400 PyObject
*list
, *tuple
;
402 list
= PyList_New (0);
406 if (iterate_over_inferiors (build_inferior_list
, list
))
412 tuple
= PyList_AsTuple (list
);
418 /* Membuf and memory manipulation. */
420 /* Implementation of Inferior.read_memory (address, length).
421 Returns a Python buffer object with LENGTH bytes of the inferior's
422 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
423 with a python exception set. */
425 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
427 CORE_ADDR addr
, length
;
429 membuf_object
*membuf_obj
;
430 PyObject
*addr_obj
, *length_obj
, *result
;
431 volatile struct gdb_exception except
;
432 static char *keywords
[] = { "address", "length", NULL
};
434 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
435 &addr_obj
, &length_obj
))
438 if (get_addr_from_python (addr_obj
, &addr
) < 0
439 || get_addr_from_python (length_obj
, &length
) < 0)
442 TRY_CATCH (except
, RETURN_MASK_ALL
)
444 buffer
= xmalloc (length
);
446 read_memory (addr
, buffer
, length
);
448 if (except
.reason
< 0)
451 GDB_PY_HANDLE_EXCEPTION (except
);
454 membuf_obj
= PyObject_New (membuf_object
, &membuf_object_type
);
455 if (membuf_obj
== NULL
)
461 membuf_obj
->buffer
= buffer
;
462 membuf_obj
->addr
= addr
;
463 membuf_obj
->length
= length
;
466 result
= PyMemoryView_FromObject ((PyObject
*) membuf_obj
);
468 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
, 0,
471 Py_DECREF (membuf_obj
);
476 /* Implementation of Inferior.write_memory (address, buffer [, length]).
477 Writes the contents of BUFFER (a Python object supporting the read
478 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
479 bytes from BUFFER, or its entire contents if the argument is not
480 provided. The function returns nothing. Returns NULL on error, with
481 a python exception set. */
483 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
487 CORE_ADDR addr
, length
;
488 PyObject
*addr_obj
, *length_obj
= NULL
;
489 volatile struct gdb_exception except
;
490 static char *keywords
[] = { "address", "buffer", "length", NULL
};
494 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os*|O", keywords
,
502 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os#|O", keywords
,
503 &addr_obj
, &buffer
, &buf_len
,
508 if (get_addr_from_python (addr_obj
, &addr
) < 0)
513 else if (get_addr_from_python (length_obj
, &length
) < 0)
516 TRY_CATCH (except
, RETURN_MASK_ALL
)
518 write_memory_with_notification (addr
, (gdb_byte
*) buffer
, length
);
521 PyBuffer_Release (&pybuf
);
523 GDB_PY_HANDLE_EXCEPTION (except
);
529 PyBuffer_Release (&pybuf
);
534 /* Destructor of Membuf objects. */
536 mbpy_dealloc (PyObject
*self
)
538 xfree (((membuf_object
*) self
)->buffer
);
539 Py_TYPE (self
)->tp_free (self
);
542 /* Return a description of the Membuf object. */
544 mbpy_str (PyObject
*self
)
546 membuf_object
*membuf_obj
= (membuf_object
*) self
;
548 return PyString_FromFormat (_("Memory buffer for address %s, \
549 which is %s bytes long."),
550 paddress (python_gdbarch
, membuf_obj
->addr
),
551 pulongest (membuf_obj
->length
));
557 get_buffer (PyObject
*self
, Py_buffer
*buf
, int flags
)
559 membuf_object
*membuf_obj
= (membuf_object
*) self
;
562 ret
= PyBuffer_FillInfo (buf
, self
, membuf_obj
->buffer
,
563 membuf_obj
->length
, 0,
573 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
575 membuf_object
*membuf_obj
= (membuf_object
*) self
;
579 PyErr_SetString (PyExc_SystemError
,
580 _("The memory buffer supports only one segment."));
584 *ptrptr
= membuf_obj
->buffer
;
586 return membuf_obj
->length
;
590 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
592 return get_read_buffer (self
, segment
, ptrptr
);
596 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
599 *lenp
= ((membuf_object
*) self
)->length
;
605 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
610 ret
= get_read_buffer (self
, segment
, &ptr
);
611 *ptrptr
= (char *) ptr
;
619 gdb.search_memory (address, length, pattern). ADDRESS is the
620 address to start the search. LENGTH specifies the scope of the
621 search from ADDRESS. PATTERN is the pattern to search for (and
622 must be a Python object supporting the buffer protocol).
623 Returns a Python Long object holding the address where the pattern
624 was located, or if the pattern was not found, returns None. Returns NULL
625 on error, with a python exception set. */
627 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
629 CORE_ADDR start_addr
, length
;
630 static char *keywords
[] = { "address", "length", "pattern", NULL
};
631 PyObject
*start_addr_obj
, *length_obj
;
632 volatile struct gdb_exception except
;
633 Py_ssize_t pattern_size
;
635 CORE_ADDR found_addr
;
640 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOs*", keywords
,
641 &start_addr_obj
, &length_obj
,
646 pattern_size
= pybuf
.len
;
650 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOO", keywords
,
651 &start_addr_obj
, &length_obj
,
655 if (!PyObject_CheckReadBuffer (pattern
))
657 PyErr_SetString (PyExc_RuntimeError
,
658 _("The pattern is not a Python buffer."));
663 if (PyObject_AsReadBuffer (pattern
, &buffer
, &pattern_size
) == -1)
667 if (get_addr_from_python (start_addr_obj
, &start_addr
) < 0)
670 if (get_addr_from_python (length_obj
, &length
) < 0)
675 PyErr_SetString (PyExc_ValueError
,
676 _("Search range is empty."));
679 /* Watch for overflows. */
680 else if (length
> CORE_ADDR_MAX
681 || (start_addr
+ length
- 1) < start_addr
)
683 PyErr_SetString (PyExc_ValueError
,
684 _("The search range is too large."));
688 TRY_CATCH (except
, RETURN_MASK_ALL
)
690 found
= target_search_memory (start_addr
, length
,
691 buffer
, pattern_size
,
695 PyBuffer_Release (&pybuf
);
697 GDB_PY_HANDLE_EXCEPTION (except
);
700 return PyLong_FromLong (found_addr
);
706 PyBuffer_Release (&pybuf
);
711 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
712 Returns True if this inferior object still exists in GDB. */
715 infpy_is_valid (PyObject
*self
, PyObject
*args
)
717 inferior_object
*inf
= (inferior_object
*) self
;
726 infpy_dealloc (PyObject
*obj
)
728 inferior_object
*inf_obj
= (inferior_object
*) obj
;
729 struct inferior
*inf
= inf_obj
->inferior
;
734 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
737 /* Clear the INFERIOR pointer in an Inferior object and clear the
740 py_free_inferior (struct inferior
*inf
, void *datum
)
743 struct cleanup
*cleanup
;
744 inferior_object
*inf_obj
= datum
;
745 struct threadlist_entry
*th_entry
, *th_tmp
;
747 if (!gdb_python_initialized
)
750 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
752 inf_obj
->inferior
= NULL
;
754 /* Deallocate threads list. */
755 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
757 Py_DECREF (th_entry
->thread_obj
);
760 th_entry
= th_entry
->next
;
764 inf_obj
->nthreads
= 0;
766 Py_DECREF ((PyObject
*) inf_obj
);
767 do_cleanups (cleanup
);
770 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
771 Returns the current inferior object. */
774 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
778 inf_obj
= inferior_to_inferior_object (current_inferior ());
785 gdbpy_initialize_inferior (void)
787 if (PyType_Ready (&inferior_object_type
) < 0)
790 if (gdb_pymodule_addobject (gdb_module
, "Inferior",
791 (PyObject
*) &inferior_object_type
) < 0)
795 register_inferior_data_with_cleanup (NULL
, py_free_inferior
);
797 observer_attach_new_thread (add_thread_object
);
798 observer_attach_thread_exit (delete_thread_object
);
799 observer_attach_normal_stop (python_on_normal_stop
);
800 observer_attach_target_resumed (python_on_resume
);
801 observer_attach_inferior_exit (python_inferior_exit
);
802 observer_attach_new_objfile (python_new_objfile
);
804 membuf_object_type
.tp_new
= PyType_GenericNew
;
805 if (PyType_Ready (&membuf_object_type
) < 0)
808 return gdb_pymodule_addobject (gdb_module
, "Membuf", (PyObject
*)
809 &membuf_object_type
);
812 static PyGetSetDef inferior_object_getset
[] =
814 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
815 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
817 { "was_attached", infpy_get_was_attached
, NULL
,
818 "True if the inferior was created using 'attach'.", NULL
},
822 static PyMethodDef inferior_object_methods
[] =
824 { "is_valid", infpy_is_valid
, METH_NOARGS
,
825 "is_valid () -> Boolean.\n\
826 Return true if this inferior is valid, false if not." },
827 { "threads", infpy_threads
, METH_NOARGS
,
828 "Return all the threads of this inferior." },
829 { "read_memory", (PyCFunction
) infpy_read_memory
,
830 METH_VARARGS
| METH_KEYWORDS
,
831 "read_memory (address, length) -> buffer\n\
832 Return a buffer object for reading from the inferior's memory." },
833 { "write_memory", (PyCFunction
) infpy_write_memory
,
834 METH_VARARGS
| METH_KEYWORDS
,
835 "write_memory (address, buffer [, length])\n\
836 Write the given buffer object to the inferior's memory." },
837 { "search_memory", (PyCFunction
) infpy_search_memory
,
838 METH_VARARGS
| METH_KEYWORDS
,
839 "search_memory (address, length, pattern) -> long\n\
840 Return a long with the address of a match, or None." },
844 static PyTypeObject inferior_object_type
=
846 PyVarObject_HEAD_INIT (NULL
, 0)
847 "gdb.Inferior", /* tp_name */
848 sizeof (inferior_object
), /* tp_basicsize */
850 infpy_dealloc
, /* tp_dealloc */
856 0, /* tp_as_number */
857 0, /* tp_as_sequence */
858 0, /* tp_as_mapping */
864 0, /* tp_as_buffer */
865 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
866 "GDB inferior object", /* tp_doc */
869 0, /* tp_richcompare */
870 0, /* tp_weaklistoffset */
873 inferior_object_methods
, /* tp_methods */
875 inferior_object_getset
, /* tp_getset */
878 0, /* tp_descr_get */
879 0, /* tp_descr_set */
880 0, /* tp_dictoffset */
887 static PyBufferProcs buffer_procs
=
894 /* Python doesn't provide a decent way to get compatibility here. */
895 #if HAVE_LIBPYTHON2_4
896 #define CHARBUFFERPROC_NAME getcharbufferproc
898 #define CHARBUFFERPROC_NAME charbufferproc
901 static PyBufferProcs buffer_procs
= {
905 /* The cast here works around a difference between Python 2.4 and
907 (CHARBUFFERPROC_NAME
) get_char_buffer
911 static PyTypeObject membuf_object_type
= {
912 PyVarObject_HEAD_INIT (NULL
, 0)
913 "gdb.Membuf", /*tp_name*/
914 sizeof (membuf_object
), /*tp_basicsize*/
916 mbpy_dealloc
, /*tp_dealloc*/
923 0, /*tp_as_sequence*/
930 &buffer_procs
, /*tp_as_buffer*/
931 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
932 "GDB memory buffer object", /*tp_doc*/
935 0, /* tp_richcompare */
936 0, /* tp_weaklistoffset */
944 0, /* tp_descr_get */
945 0, /* tp_descr_set */
946 0, /* tp_dictoffset */