1 /* Python interface to inferiors.
3 Copyright (C) 2009-2012 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
;
56 static const struct inferior_data
*infpy_inf_data_key
;
62 /* These are kept just for mbpy_str. */
67 static PyTypeObject membuf_object_type
;
69 /* Require that INFERIOR be a valid inferior ID. */
70 #define INFPY_REQUIRE_VALID(Inferior) \
72 if (!Inferior->inferior) \
74 PyErr_SetString (PyExc_RuntimeError, \
75 _("Inferior no longer exists.")); \
81 python_on_normal_stop (struct bpstats
*bs
, int print_frame
)
83 struct cleanup
*cleanup
;
84 enum gdb_signal stop_signal
;
86 if (!find_thread_ptid (inferior_ptid
))
89 stop_signal
= inferior_thread ()->suspend
.stop_signal
;
91 cleanup
= ensure_python_env (get_current_arch (), current_language
);
93 if (emit_stop_event (bs
, stop_signal
) < 0)
96 do_cleanups (cleanup
);
100 python_on_resume (ptid_t ptid
)
102 struct cleanup
*cleanup
;
104 cleanup
= ensure_python_env (target_gdbarch (), current_language
);
106 if (emit_continue_event (ptid
) < 0)
107 gdbpy_print_stack ();
109 do_cleanups (cleanup
);
113 python_inferior_exit (struct inferior
*inf
)
115 struct cleanup
*cleanup
;
116 const LONGEST
*exit_code
= NULL
;
118 cleanup
= ensure_python_env (target_gdbarch (), current_language
);
120 if (inf
->has_exit_code
)
121 exit_code
= &inf
->exit_code
;
123 if (emit_exited_event (exit_code
, inf
) < 0)
124 gdbpy_print_stack ();
126 do_cleanups (cleanup
);
129 /* Callback used to notify Python listeners about new objfiles loaded in the
133 python_new_objfile (struct objfile
*objfile
)
135 struct cleanup
*cleanup
;
140 cleanup
= ensure_python_env (get_objfile_arch (objfile
), current_language
);
142 if (emit_new_objfile_event (objfile
) < 0)
143 gdbpy_print_stack ();
145 do_cleanups (cleanup
);
148 /* Return a reference to the Python object of type Inferior
149 representing INFERIOR. If the object has already been created,
150 return it and increment the reference count, otherwise, create it.
151 Return NULL on failure. */
153 inferior_to_inferior_object (struct inferior
*inferior
)
155 inferior_object
*inf_obj
;
157 inf_obj
= inferior_data (inferior
, infpy_inf_data_key
);
160 inf_obj
= PyObject_New (inferior_object
, &inferior_object_type
);
164 inf_obj
->inferior
= inferior
;
165 inf_obj
->threads
= NULL
;
166 inf_obj
->nthreads
= 0;
168 set_inferior_data (inferior
, infpy_inf_data_key
, inf_obj
);
172 Py_INCREF ((PyObject
*)inf_obj
);
174 return (PyObject
*) inf_obj
;
177 /* Finds the Python Inferior object for the given PID. Returns a
178 reference, or NULL if PID does not match any inferior object. */
181 find_inferior_object (int pid
)
183 struct inferior
*inf
= find_inferior_pid (pid
);
186 return inferior_to_inferior_object (inf
);
192 find_thread_object (ptid_t ptid
)
195 struct threadlist_entry
*thread
;
197 thread_object
*found
= NULL
;
203 inf_obj
= find_inferior_object (pid
);
208 for (thread
= ((inferior_object
*)inf_obj
)->threads
; thread
;
209 thread
= thread
->next
)
210 if (ptid_equal (thread
->thread_obj
->thread
->ptid
, ptid
))
212 found
= thread
->thread_obj
;
225 add_thread_object (struct thread_info
*tp
)
227 struct cleanup
*cleanup
;
228 thread_object
*thread_obj
;
229 inferior_object
*inf_obj
;
230 struct threadlist_entry
*entry
;
232 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
234 thread_obj
= create_thread_object (tp
);
237 gdbpy_print_stack ();
238 do_cleanups (cleanup
);
242 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
244 entry
= xmalloc (sizeof (struct threadlist_entry
));
245 entry
->thread_obj
= thread_obj
;
246 entry
->next
= inf_obj
->threads
;
248 inf_obj
->threads
= entry
;
251 do_cleanups (cleanup
);
255 delete_thread_object (struct thread_info
*tp
, int ignore
)
257 struct cleanup
*cleanup
;
258 inferior_object
*inf_obj
;
259 struct threadlist_entry
**entry
, *tmp
;
261 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
263 inf_obj
= (inferior_object
*) find_inferior_object (PIDGET(tp
->ptid
));
266 do_cleanups (cleanup
);
270 /* Find thread entry in its inferior's thread_list. */
271 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
273 if ((*entry
)->thread_obj
->thread
== tp
)
279 do_cleanups (cleanup
);
284 tmp
->thread_obj
->thread
= NULL
;
286 *entry
= (*entry
)->next
;
289 Py_DECREF (tmp
->thread_obj
);
293 do_cleanups (cleanup
);
297 infpy_threads (PyObject
*self
, PyObject
*args
)
300 struct threadlist_entry
*entry
;
301 inferior_object
*inf_obj
= (inferior_object
*) self
;
303 volatile struct gdb_exception except
;
305 INFPY_REQUIRE_VALID (inf_obj
);
307 TRY_CATCH (except
, RETURN_MASK_ALL
)
308 update_thread_list ();
309 GDB_PY_HANDLE_EXCEPTION (except
);
311 tuple
= PyTuple_New (inf_obj
->nthreads
);
315 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
316 i
++, entry
= entry
->next
)
318 Py_INCREF (entry
->thread_obj
);
319 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
326 infpy_get_num (PyObject
*self
, void *closure
)
328 inferior_object
*inf
= (inferior_object
*) self
;
330 INFPY_REQUIRE_VALID (inf
);
332 return PyLong_FromLong (inf
->inferior
->num
);
336 infpy_get_pid (PyObject
*self
, void *closure
)
338 inferior_object
*inf
= (inferior_object
*) self
;
340 INFPY_REQUIRE_VALID (inf
);
342 return PyLong_FromLong (inf
->inferior
->pid
);
346 infpy_get_was_attached (PyObject
*self
, void *closure
)
348 inferior_object
*inf
= (inferior_object
*) self
;
350 INFPY_REQUIRE_VALID (inf
);
351 if (inf
->inferior
->attach_flag
)
357 build_inferior_list (struct inferior
*inf
, void *arg
)
359 PyObject
*list
= arg
;
360 PyObject
*inferior
= inferior_to_inferior_object (inf
);
366 success
= PyList_Append (list
, inferior
);
367 Py_DECREF (inferior
);
375 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
376 Returns a tuple of all inferiors. */
378 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
380 PyObject
*list
, *tuple
;
382 list
= PyList_New (0);
386 if (iterate_over_inferiors (build_inferior_list
, list
))
392 tuple
= PyList_AsTuple (list
);
398 /* Membuf and memory manipulation. */
400 /* Implementation of Inferior.read_memory (address, length).
401 Returns a Python buffer object with LENGTH bytes of the inferior's
402 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
403 with a python exception set. */
405 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
408 CORE_ADDR addr
, length
;
410 membuf_object
*membuf_obj
;
411 PyObject
*addr_obj
, *length_obj
, *result
;
412 volatile struct gdb_exception except
;
413 static char *keywords
[] = { "address", "length", NULL
};
415 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
416 &addr_obj
, &length_obj
))
419 TRY_CATCH (except
, RETURN_MASK_ALL
)
421 if (!get_addr_from_python (addr_obj
, &addr
)
422 || !get_addr_from_python (length_obj
, &length
))
428 buffer
= xmalloc (length
);
430 read_memory (addr
, buffer
, length
);
432 if (except
.reason
< 0)
435 GDB_PY_HANDLE_EXCEPTION (except
);
444 membuf_obj
= PyObject_New (membuf_object
, &membuf_object_type
);
445 if (membuf_obj
== NULL
)
448 PyErr_SetString (PyExc_MemoryError
,
449 _("Could not allocate memory buffer object."));
453 membuf_obj
->buffer
= buffer
;
454 membuf_obj
->addr
= addr
;
455 membuf_obj
->length
= length
;
458 result
= PyMemoryView_FromObject ((PyObject
*) membuf_obj
);
460 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
, 0,
463 Py_DECREF (membuf_obj
);
468 /* Implementation of Inferior.write_memory (address, buffer [, length]).
469 Writes the contents of BUFFER (a Python object supporting the read
470 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
471 bytes from BUFFER, or its entire contents if the argument is not
472 provided. The function returns nothing. Returns NULL on error, with
473 a python exception set. */
475 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
480 CORE_ADDR addr
, length
;
481 PyObject
*addr_obj
, *length_obj
= NULL
;
482 volatile struct gdb_exception except
;
483 static char *keywords
[] = { "address", "buffer", "length", NULL
};
487 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os*|O", keywords
,
495 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os#|O", keywords
,
496 &addr_obj
, &buffer
, &buf_len
,
501 TRY_CATCH (except
, RETURN_MASK_ALL
)
503 if (!get_addr_from_python (addr_obj
, &addr
))
511 else if (!get_addr_from_python (length_obj
, &length
))
516 write_memory_with_notification (addr
, buffer
, length
);
519 PyBuffer_Release (&pybuf
);
521 GDB_PY_HANDLE_EXCEPTION (except
);
530 /* Destructor of Membuf objects. */
532 mbpy_dealloc (PyObject
*self
)
534 xfree (((membuf_object
*) self
)->buffer
);
535 Py_TYPE (self
)->tp_free (self
);
538 /* Return a description of the Membuf object. */
540 mbpy_str (PyObject
*self
)
542 membuf_object
*membuf_obj
= (membuf_object
*) self
;
544 return PyString_FromFormat (_("Memory buffer for address %s, \
545 which is %s bytes long."),
546 paddress (python_gdbarch
, membuf_obj
->addr
),
547 pulongest (membuf_obj
->length
));
553 get_buffer (PyObject
*self
, Py_buffer
*buf
, int flags
)
555 membuf_object
*membuf_obj
= (membuf_object
*) self
;
558 ret
= PyBuffer_FillInfo (buf
, self
, membuf_obj
->buffer
,
559 membuf_obj
->length
, 0,
569 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
571 membuf_object
*membuf_obj
= (membuf_object
*) self
;
575 PyErr_SetString (PyExc_SystemError
,
576 _("The memory buffer supports only one segment."));
580 *ptrptr
= membuf_obj
->buffer
;
582 return membuf_obj
->length
;
586 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
588 return get_read_buffer (self
, segment
, ptrptr
);
592 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
595 *lenp
= ((membuf_object
*) self
)->length
;
601 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
606 ret
= get_read_buffer (self
, segment
, &ptr
);
607 *ptrptr
= (char *) ptr
;
615 gdb.search_memory (address, length, pattern). ADDRESS is the
616 address to start the search. LENGTH specifies the scope of the
617 search from ADDRESS. PATTERN is the pattern to search for (and
618 must be a Python object supporting the buffer protocol).
619 Returns a Python Long object holding the address where the pattern
620 was located, or if the pattern was not found, returns None. Returns NULL
621 on error, with a python exception set. */
623 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
625 CORE_ADDR start_addr
, length
;
626 static char *keywords
[] = { "address", "length", "pattern", NULL
};
627 PyObject
*start_addr_obj
, *length_obj
;
628 volatile struct gdb_exception except
;
629 Py_ssize_t pattern_size
;
631 CORE_ADDR found_addr
;
636 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOs*", keywords
,
637 &start_addr_obj
, &length_obj
,
642 pattern_size
= pybuf
.len
;
646 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOO", keywords
,
647 &start_addr_obj
, &length_obj
,
651 if (!PyObject_CheckReadBuffer (pattern
))
653 PyErr_SetString (PyExc_RuntimeError
,
654 _("The pattern is not a Python buffer."));
659 if (PyObject_AsReadBuffer (pattern
, &buffer
, &pattern_size
) == -1)
663 if (get_addr_from_python (start_addr_obj
, &start_addr
)
664 && get_addr_from_python (length_obj
, &length
))
668 PyErr_SetString (PyExc_ValueError
,
669 _("Search range is empty."));
672 PyBuffer_Release (&pybuf
);
676 /* Watch for overflows. */
677 else if (length
> CORE_ADDR_MAX
678 || (start_addr
+ length
- 1) < start_addr
)
680 PyErr_SetString (PyExc_ValueError
,
681 _("The search range is too large."));
684 PyBuffer_Release (&pybuf
);
692 TRY_CATCH (except
, RETURN_MASK_ALL
)
694 found
= target_search_memory (start_addr
, length
,
695 buffer
, pattern_size
,
698 GDB_PY_HANDLE_EXCEPTION (except
);
701 PyBuffer_Release (&pybuf
);
705 return PyLong_FromLong (found_addr
);
710 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
711 Returns True if this inferior object still exists in GDB. */
714 infpy_is_valid (PyObject
*self
, PyObject
*args
)
716 inferior_object
*inf
= (inferior_object
*) self
;
725 infpy_dealloc (PyObject
*obj
)
727 inferior_object
*inf_obj
= (inferior_object
*) obj
;
728 struct inferior
*inf
= inf_obj
->inferior
;
733 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
736 /* Clear the INFERIOR pointer in an Inferior object and clear the
739 py_free_inferior (struct inferior
*inf
, void *datum
)
742 struct cleanup
*cleanup
;
743 inferior_object
*inf_obj
= datum
;
744 struct threadlist_entry
*th_entry
, *th_tmp
;
746 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
748 inf_obj
->inferior
= NULL
;
750 /* Deallocate threads list. */
751 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
753 Py_DECREF (th_entry
->thread_obj
);
756 th_entry
= th_entry
->next
;
760 inf_obj
->nthreads
= 0;
762 Py_DECREF ((PyObject
*) inf_obj
);
763 do_cleanups (cleanup
);
766 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
767 Returns the current inferior object. */
770 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
774 inf_obj
= inferior_to_inferior_object (current_inferior ());
781 gdbpy_initialize_inferior (void)
783 if (PyType_Ready (&inferior_object_type
) < 0)
786 Py_INCREF (&inferior_object_type
);
787 PyModule_AddObject (gdb_module
, "Inferior",
788 (PyObject
*) &inferior_object_type
);
791 register_inferior_data_with_cleanup (NULL
, py_free_inferior
);
793 observer_attach_new_thread (add_thread_object
);
794 observer_attach_thread_exit (delete_thread_object
);
795 observer_attach_normal_stop (python_on_normal_stop
);
796 observer_attach_target_resumed (python_on_resume
);
797 observer_attach_inferior_exit (python_inferior_exit
);
798 observer_attach_new_objfile (python_new_objfile
);
800 membuf_object_type
.tp_new
= PyType_GenericNew
;
801 if (PyType_Ready (&membuf_object_type
) < 0)
804 Py_INCREF (&membuf_object_type
);
805 PyModule_AddObject (gdb_module
, "Membuf", (PyObject
*)
806 &membuf_object_type
);
809 static PyGetSetDef inferior_object_getset
[] =
811 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
812 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
814 { "was_attached", infpy_get_was_attached
, NULL
,
815 "True if the inferior was created using 'attach'.", NULL
},
819 static PyMethodDef inferior_object_methods
[] =
821 { "is_valid", infpy_is_valid
, METH_NOARGS
,
822 "is_valid () -> Boolean.\n\
823 Return true if this inferior is valid, false if not." },
824 { "threads", infpy_threads
, METH_NOARGS
,
825 "Return all the threads of this inferior." },
826 { "read_memory", (PyCFunction
) infpy_read_memory
,
827 METH_VARARGS
| METH_KEYWORDS
,
828 "read_memory (address, length) -> buffer\n\
829 Return a buffer object for reading from the inferior's memory." },
830 { "write_memory", (PyCFunction
) infpy_write_memory
,
831 METH_VARARGS
| METH_KEYWORDS
,
832 "write_memory (address, buffer [, length])\n\
833 Write the given buffer object to the inferior's memory." },
834 { "search_memory", (PyCFunction
) infpy_search_memory
,
835 METH_VARARGS
| METH_KEYWORDS
,
836 "search_memory (address, length, pattern) -> long\n\
837 Return a long with the address of a match, or None." },
841 static PyTypeObject inferior_object_type
=
843 PyVarObject_HEAD_INIT (NULL
, 0)
844 "gdb.Inferior", /* tp_name */
845 sizeof (inferior_object
), /* tp_basicsize */
847 infpy_dealloc
, /* tp_dealloc */
853 0, /* tp_as_number */
854 0, /* tp_as_sequence */
855 0, /* tp_as_mapping */
861 0, /* tp_as_buffer */
862 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
863 "GDB inferior object", /* tp_doc */
866 0, /* tp_richcompare */
867 0, /* tp_weaklistoffset */
870 inferior_object_methods
, /* tp_methods */
872 inferior_object_getset
, /* tp_getset */
875 0, /* tp_descr_get */
876 0, /* tp_descr_set */
877 0, /* tp_dictoffset */
884 static PyBufferProcs buffer_procs
=
891 /* Python doesn't provide a decent way to get compatibility here. */
892 #if HAVE_LIBPYTHON2_4
893 #define CHARBUFFERPROC_NAME getcharbufferproc
895 #define CHARBUFFERPROC_NAME charbufferproc
898 static PyBufferProcs buffer_procs
= {
902 /* The cast here works around a difference between Python 2.4 and
904 (CHARBUFFERPROC_NAME
) get_char_buffer
908 static PyTypeObject membuf_object_type
= {
909 PyVarObject_HEAD_INIT (NULL
, 0)
910 "gdb.Membuf", /*tp_name*/
911 sizeof (membuf_object
), /*tp_basicsize*/
913 mbpy_dealloc
, /*tp_dealloc*/
920 0, /*tp_as_sequence*/
927 &buffer_procs
, /*tp_as_buffer*/
928 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
929 "GDB memory buffer object", /*tp_doc*/
932 0, /* tp_richcompare */
933 0, /* tp_weaklistoffset */
941 0, /* tp_descr_get */
942 0, /* tp_descr_set */
943 0, /* tp_dictoffset */