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
;
304 INFPY_REQUIRE_VALID (inf_obj
);
306 tuple
= PyTuple_New (inf_obj
->nthreads
);
310 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
311 i
++, entry
= entry
->next
)
313 Py_INCREF (entry
->thread_obj
);
314 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
321 infpy_get_num (PyObject
*self
, void *closure
)
323 inferior_object
*inf
= (inferior_object
*) self
;
325 INFPY_REQUIRE_VALID (inf
);
327 return PyLong_FromLong (inf
->inferior
->num
);
331 infpy_get_pid (PyObject
*self
, void *closure
)
333 inferior_object
*inf
= (inferior_object
*) self
;
335 INFPY_REQUIRE_VALID (inf
);
337 return PyLong_FromLong (inf
->inferior
->pid
);
341 infpy_get_was_attached (PyObject
*self
, void *closure
)
343 inferior_object
*inf
= (inferior_object
*) self
;
345 INFPY_REQUIRE_VALID (inf
);
346 if (inf
->inferior
->attach_flag
)
352 build_inferior_list (struct inferior
*inf
, void *arg
)
354 PyObject
*list
= arg
;
355 PyObject
*inferior
= inferior_to_inferior_object (inf
);
361 success
= PyList_Append (list
, inferior
);
362 Py_DECREF (inferior
);
370 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
371 Returns a tuple of all inferiors. */
373 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
375 PyObject
*list
, *tuple
;
377 list
= PyList_New (0);
381 if (iterate_over_inferiors (build_inferior_list
, list
))
387 tuple
= PyList_AsTuple (list
);
393 /* Membuf and memory manipulation. */
395 /* Implementation of Inferior.read_memory (address, length).
396 Returns a Python buffer object with LENGTH bytes of the inferior's
397 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
398 with a python exception set. */
400 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
403 CORE_ADDR addr
, length
;
405 membuf_object
*membuf_obj
;
406 PyObject
*addr_obj
, *length_obj
, *result
;
407 volatile struct gdb_exception except
;
408 static char *keywords
[] = { "address", "length", NULL
};
410 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
411 &addr_obj
, &length_obj
))
414 TRY_CATCH (except
, RETURN_MASK_ALL
)
416 if (!get_addr_from_python (addr_obj
, &addr
)
417 || !get_addr_from_python (length_obj
, &length
))
423 buffer
= xmalloc (length
);
425 read_memory (addr
, buffer
, length
);
427 if (except
.reason
< 0)
430 GDB_PY_HANDLE_EXCEPTION (except
);
439 membuf_obj
= PyObject_New (membuf_object
, &membuf_object_type
);
440 if (membuf_obj
== NULL
)
443 PyErr_SetString (PyExc_MemoryError
,
444 _("Could not allocate memory buffer object."));
448 membuf_obj
->buffer
= buffer
;
449 membuf_obj
->addr
= addr
;
450 membuf_obj
->length
= length
;
452 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
, 0,
454 Py_DECREF (membuf_obj
);
458 /* Implementation of Inferior.write_memory (address, buffer [, length]).
459 Writes the contents of BUFFER (a Python object supporting the read
460 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
461 bytes from BUFFER, or its entire contents if the argument is not
462 provided. The function returns nothing. Returns NULL on error, with
463 a python exception set. */
465 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
470 CORE_ADDR addr
, length
;
471 PyObject
*addr_obj
, *length_obj
= NULL
;
472 volatile struct gdb_exception except
;
473 static char *keywords
[] = { "address", "buffer", "length", NULL
};
476 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os#|O", keywords
,
477 &addr_obj
, &buffer
, &buf_len
,
481 TRY_CATCH (except
, RETURN_MASK_ALL
)
483 if (!get_addr_from_python (addr_obj
, &addr
))
491 else if (!get_addr_from_python (length_obj
, &length
))
496 write_memory (addr
, buffer
, length
);
498 GDB_PY_HANDLE_EXCEPTION (except
);
506 /* Destructor of Membuf objects. */
508 mbpy_dealloc (PyObject
*self
)
510 xfree (((membuf_object
*) self
)->buffer
);
511 self
->ob_type
->tp_free (self
);
514 /* Return a description of the Membuf object. */
516 mbpy_str (PyObject
*self
)
518 membuf_object
*membuf_obj
= (membuf_object
*) self
;
520 return PyString_FromFormat (_("Memory buffer for address %s, \
521 which is %s bytes long."),
522 paddress (python_gdbarch
, membuf_obj
->addr
),
523 pulongest (membuf_obj
->length
));
527 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
529 membuf_object
*membuf_obj
= (membuf_object
*) self
;
533 PyErr_SetString (PyExc_SystemError
,
534 _("The memory buffer supports only one segment."));
538 *ptrptr
= membuf_obj
->buffer
;
540 return membuf_obj
->length
;
544 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
546 return get_read_buffer (self
, segment
, ptrptr
);
550 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
553 *lenp
= ((membuf_object
*) self
)->length
;
559 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
564 ret
= get_read_buffer (self
, segment
, &ptr
);
565 *ptrptr
= (char *) ptr
;
571 gdb.search_memory (address, length, pattern). ADDRESS is the
572 address to start the search. LENGTH specifies the scope of the
573 search from ADDRESS. PATTERN is the pattern to search for (and
574 must be a Python object supporting the buffer protocol).
575 Returns a Python Long object holding the address where the pattern
576 was located, or if the pattern was not found, returns None. Returns NULL
577 on error, with a python exception set. */
579 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
581 CORE_ADDR start_addr
, length
;
582 static char *keywords
[] = { "address", "length", "pattern", NULL
};
583 PyObject
*pattern
, *start_addr_obj
, *length_obj
;
584 volatile struct gdb_exception except
;
585 Py_ssize_t pattern_size
;
587 CORE_ADDR found_addr
;
590 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOO", keywords
,
591 &start_addr_obj
, &length_obj
,
595 if (get_addr_from_python (start_addr_obj
, &start_addr
)
596 && get_addr_from_python (length_obj
, &length
))
600 PyErr_SetString (PyExc_ValueError
,
601 _("Search range is empty."));
604 /* Watch for overflows. */
605 else if (length
> CORE_ADDR_MAX
606 || (start_addr
+ length
- 1) < start_addr
)
608 PyErr_SetString (PyExc_ValueError
,
609 _("The search range is too large."));
617 if (!PyObject_CheckReadBuffer (pattern
))
619 PyErr_SetString (PyExc_RuntimeError
,
620 _("The pattern is not a Python buffer."));
625 if (PyObject_AsReadBuffer (pattern
, &buffer
, &pattern_size
) == -1)
628 TRY_CATCH (except
, RETURN_MASK_ALL
)
630 found
= target_search_memory (start_addr
, length
,
631 buffer
, pattern_size
,
634 GDB_PY_HANDLE_EXCEPTION (except
);
637 return PyLong_FromLong (found_addr
);
642 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
643 Returns True if this inferior object still exists in GDB. */
646 infpy_is_valid (PyObject
*self
, PyObject
*args
)
648 inferior_object
*inf
= (inferior_object
*) self
;
657 infpy_dealloc (PyObject
*obj
)
659 inferior_object
*inf_obj
= (inferior_object
*) obj
;
660 struct inferior
*inf
= inf_obj
->inferior
;
665 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
668 /* Clear the INFERIOR pointer in an Inferior object and clear the
671 py_free_inferior (struct inferior
*inf
, void *datum
)
674 struct cleanup
*cleanup
;
675 inferior_object
*inf_obj
= datum
;
676 struct threadlist_entry
*th_entry
, *th_tmp
;
678 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
680 inf_obj
->inferior
= NULL
;
682 /* Deallocate threads list. */
683 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
685 Py_DECREF (th_entry
->thread_obj
);
688 th_entry
= th_entry
->next
;
692 inf_obj
->nthreads
= 0;
694 Py_DECREF ((PyObject
*) inf_obj
);
695 do_cleanups (cleanup
);
698 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
699 Returns the current inferior object. */
702 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
706 inf_obj
= inferior_to_inferior_object (current_inferior ());
713 gdbpy_initialize_inferior (void)
715 if (PyType_Ready (&inferior_object_type
) < 0)
718 Py_INCREF (&inferior_object_type
);
719 PyModule_AddObject (gdb_module
, "Inferior",
720 (PyObject
*) &inferior_object_type
);
723 register_inferior_data_with_cleanup (py_free_inferior
);
725 observer_attach_new_thread (add_thread_object
);
726 observer_attach_thread_exit (delete_thread_object
);
727 observer_attach_normal_stop (python_on_normal_stop
);
728 observer_attach_target_resumed (python_on_resume
);
729 observer_attach_inferior_exit (python_inferior_exit
);
730 observer_attach_new_objfile (python_new_objfile
);
732 membuf_object_type
.tp_new
= PyType_GenericNew
;
733 if (PyType_Ready (&membuf_object_type
) < 0)
736 Py_INCREF (&membuf_object_type
);
737 PyModule_AddObject (gdb_module
, "Membuf", (PyObject
*)
738 &membuf_object_type
);
741 static PyGetSetDef inferior_object_getset
[] =
743 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
744 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
746 { "was_attached", infpy_get_was_attached
, NULL
,
747 "True if the inferior was created using 'attach'.", NULL
},
751 static PyMethodDef inferior_object_methods
[] =
753 { "is_valid", infpy_is_valid
, METH_NOARGS
,
754 "is_valid () -> Boolean.\n\
755 Return true if this inferior is valid, false if not." },
756 { "threads", infpy_threads
, METH_NOARGS
,
757 "Return all the threads of this inferior." },
758 { "read_memory", (PyCFunction
) infpy_read_memory
,
759 METH_VARARGS
| METH_KEYWORDS
,
760 "read_memory (address, length) -> buffer\n\
761 Return a buffer object for reading from the inferior's memory." },
762 { "write_memory", (PyCFunction
) infpy_write_memory
,
763 METH_VARARGS
| METH_KEYWORDS
,
764 "write_memory (address, buffer [, length])\n\
765 Write the given buffer object to the inferior's memory." },
766 { "search_memory", (PyCFunction
) infpy_search_memory
,
767 METH_VARARGS
| METH_KEYWORDS
,
768 "search_memory (address, length, pattern) -> long\n\
769 Return a long with the address of a match, or None." },
773 static PyTypeObject inferior_object_type
=
775 PyObject_HEAD_INIT (NULL
)
777 "gdb.Inferior", /* tp_name */
778 sizeof (inferior_object
), /* tp_basicsize */
780 infpy_dealloc
, /* tp_dealloc */
786 0, /* tp_as_number */
787 0, /* tp_as_sequence */
788 0, /* tp_as_mapping */
794 0, /* tp_as_buffer */
795 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
796 "GDB inferior object", /* tp_doc */
799 0, /* tp_richcompare */
800 0, /* tp_weaklistoffset */
803 inferior_object_methods
, /* tp_methods */
805 inferior_object_getset
, /* tp_getset */
808 0, /* tp_descr_get */
809 0, /* tp_descr_set */
810 0, /* tp_dictoffset */
815 /* Python doesn't provide a decent way to get compatibility here. */
816 #if HAVE_LIBPYTHON2_4
817 #define CHARBUFFERPROC_NAME getcharbufferproc
819 #define CHARBUFFERPROC_NAME charbufferproc
822 static PyBufferProcs buffer_procs
= {
826 /* The cast here works around a difference between Python 2.4 and
828 (CHARBUFFERPROC_NAME
) get_char_buffer
831 static PyTypeObject membuf_object_type
= {
832 PyObject_HEAD_INIT (NULL
)
834 "gdb.Membuf", /*tp_name*/
835 sizeof (membuf_object
), /*tp_basicsize*/
837 mbpy_dealloc
, /*tp_dealloc*/
844 0, /*tp_as_sequence*/
851 &buffer_procs
, /*tp_as_buffer*/
852 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
853 "GDB memory buffer object", /*tp_doc*/
856 0, /* tp_richcompare */
857 0, /* tp_weaklistoffset */
865 0, /* tp_descr_get */
866 0, /* tp_descr_set */
867 0, /* tp_dictoffset */