1 /* Python interface to inferiors.
3 Copyright (C) 2009, 2010, 2011 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 target_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 inflist_entry
*p
;
184 struct inferior
*inf
= find_inferior_pid (pid
);
187 return inferior_to_inferior_object (inf
);
193 find_thread_object (ptid_t ptid
)
196 struct threadlist_entry
*thread
;
198 thread_object
*found
= NULL
;
204 inf_obj
= find_inferior_object (pid
);
209 for (thread
= ((inferior_object
*)inf_obj
)->threads
; thread
;
210 thread
= thread
->next
)
211 if (ptid_equal (thread
->thread_obj
->thread
->ptid
, ptid
))
213 found
= thread
->thread_obj
;
226 add_thread_object (struct thread_info
*tp
)
228 struct cleanup
*cleanup
;
229 thread_object
*thread_obj
;
230 inferior_object
*inf_obj
;
231 struct threadlist_entry
*entry
;
233 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
235 thread_obj
= create_thread_object (tp
);
238 gdbpy_print_stack ();
239 do_cleanups (cleanup
);
243 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
245 entry
= xmalloc (sizeof (struct threadlist_entry
));
246 entry
->thread_obj
= thread_obj
;
247 entry
->next
= inf_obj
->threads
;
249 inf_obj
->threads
= entry
;
252 do_cleanups (cleanup
);
256 delete_thread_object (struct thread_info
*tp
, int ignore
)
258 struct cleanup
*cleanup
;
259 inferior_object
*inf_obj
;
260 thread_object
*thread_obj
;
261 struct threadlist_entry
**entry
, *tmp
;
263 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
265 inf_obj
= (inferior_object
*) find_inferior_object (PIDGET(tp
->ptid
));
268 do_cleanups (cleanup
);
272 /* Find thread entry in its inferior's thread_list. */
273 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
275 if ((*entry
)->thread_obj
->thread
== tp
)
281 do_cleanups (cleanup
);
286 tmp
->thread_obj
->thread
= NULL
;
288 *entry
= (*entry
)->next
;
291 Py_DECREF (tmp
->thread_obj
);
295 do_cleanups (cleanup
);
299 infpy_threads (PyObject
*self
, PyObject
*args
)
302 struct threadlist_entry
*entry
;
303 inferior_object
*inf_obj
= (inferior_object
*) self
;
306 INFPY_REQUIRE_VALID (inf_obj
);
308 tuple
= PyTuple_New (inf_obj
->nthreads
);
312 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
313 i
++, entry
= entry
->next
)
315 Py_INCREF (entry
->thread_obj
);
316 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
323 infpy_get_num (PyObject
*self
, void *closure
)
325 inferior_object
*inf
= (inferior_object
*) self
;
327 INFPY_REQUIRE_VALID (inf
);
329 return PyLong_FromLong (inf
->inferior
->num
);
333 infpy_get_pid (PyObject
*self
, void *closure
)
335 inferior_object
*inf
= (inferior_object
*) self
;
337 INFPY_REQUIRE_VALID (inf
);
339 return PyLong_FromLong (inf
->inferior
->pid
);
343 infpy_get_was_attached (PyObject
*self
, void *closure
)
345 inferior_object
*inf
= (inferior_object
*) self
;
347 INFPY_REQUIRE_VALID (inf
);
348 if (inf
->inferior
->attach_flag
)
354 build_inferior_list (struct inferior
*inf
, void *arg
)
356 PyObject
*list
= arg
;
357 PyObject
*inferior
= inferior_to_inferior_object (inf
);
363 success
= PyList_Append (list
, inferior
);
364 Py_DECREF (inferior
);
372 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
373 Returns a tuple of all inferiors. */
375 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
377 PyObject
*list
, *tuple
;
379 list
= PyList_New (0);
383 if (iterate_over_inferiors (build_inferior_list
, list
))
389 tuple
= PyList_AsTuple (list
);
395 /* Membuf and memory manipulation. */
397 /* Implementation of gdb.read_memory (address, length).
398 Returns a Python buffer object with LENGTH bytes of the inferior's
399 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
400 with a python exception set. */
402 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
405 CORE_ADDR addr
, length
;
407 membuf_object
*membuf_obj
;
408 PyObject
*addr_obj
, *length_obj
;
409 struct cleanup
*cleanups
;
410 volatile struct gdb_exception except
;
411 static char *keywords
[] = { "address", "length", NULL
};
413 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
414 &addr_obj
, &length_obj
))
417 cleanups
= make_cleanup (null_cleanup
, NULL
);
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
);
429 make_cleanup (xfree
, buffer
);
431 read_memory (addr
, buffer
, length
);
433 if (except
.reason
< 0)
435 do_cleanups (cleanups
);
436 GDB_PY_HANDLE_EXCEPTION (except
);
441 do_cleanups (cleanups
);
445 membuf_obj
= PyObject_New (membuf_object
, &membuf_object_type
);
446 if (membuf_obj
== NULL
)
448 PyErr_SetString (PyExc_MemoryError
,
449 _("Could not allocate memory buffer object."));
450 do_cleanups (cleanups
);
454 discard_cleanups (cleanups
);
456 membuf_obj
->buffer
= buffer
;
457 membuf_obj
->addr
= addr
;
458 membuf_obj
->length
= length
;
460 return PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
, 0,
464 /* Implementation of gdb.write_memory (address, buffer [, length]).
465 Writes the contents of BUFFER (a Python object supporting the read
466 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
467 bytes from BUFFER, or its entire contents if the argument is not
468 provided. The function returns nothing. Returns NULL on error, with
469 a python exception set. */
471 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
476 CORE_ADDR addr
, length
;
477 PyObject
*addr_obj
, *length_obj
= NULL
;
478 volatile struct gdb_exception except
;
479 static char *keywords
[] = { "address", "buffer", "length", NULL
};
482 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "Os#|O", keywords
,
483 &addr_obj
, &buffer
, &buf_len
,
487 TRY_CATCH (except
, RETURN_MASK_ALL
)
489 if (!get_addr_from_python (addr_obj
, &addr
))
497 else if (!get_addr_from_python (length_obj
, &length
))
502 write_memory (addr
, buffer
, length
);
504 GDB_PY_HANDLE_EXCEPTION (except
);
512 /* Destructor of Membuf objects. */
514 mbpy_dealloc (PyObject
*self
)
516 xfree (((membuf_object
*) self
)->buffer
);
517 self
->ob_type
->tp_free (self
);
520 /* Return a description of the Membuf object. */
522 mbpy_str (PyObject
*self
)
524 membuf_object
*membuf_obj
= (membuf_object
*) self
;
526 return PyString_FromFormat (_("Memory buffer for address %s, \
527 which is %s bytes long."),
528 paddress (python_gdbarch
, membuf_obj
->addr
),
529 pulongest (membuf_obj
->length
));
533 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
535 membuf_object
*membuf_obj
= (membuf_object
*) self
;
539 PyErr_SetString (PyExc_SystemError
,
540 _("The memory buffer supports only one segment."));
544 *ptrptr
= membuf_obj
->buffer
;
546 return membuf_obj
->length
;
550 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
552 return get_read_buffer (self
, segment
, ptrptr
);
556 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
559 *lenp
= ((membuf_object
*) self
)->length
;
565 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
570 ret
= get_read_buffer (self
, segment
, &ptr
);
571 *ptrptr
= (char *) ptr
;
577 gdb.search_memory (address, length, pattern). ADDRESS is the
578 address to start the search. LENGTH specifies the scope of the
579 search from ADDRESS. PATTERN is the pattern to search for (and
580 must be a Python object supporting the buffer protocol).
581 Returns a Python Long object holding the address where the pattern
582 was located, or if the pattern was not found, returns None. Returns NULL
583 on error, with a python exception set. */
585 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
587 CORE_ADDR start_addr
, length
;
588 static char *keywords
[] = { "address", "length", "pattern", NULL
};
589 PyObject
*pattern
, *start_addr_obj
, *length_obj
;
590 volatile struct gdb_exception except
;
591 Py_ssize_t pattern_size
;
593 CORE_ADDR found_addr
;
596 if (! PyArg_ParseTupleAndKeywords (args
, kw
, "OOO", keywords
,
597 &start_addr_obj
, &length_obj
,
601 if (get_addr_from_python (start_addr_obj
, &start_addr
)
602 && get_addr_from_python (length_obj
, &length
))
606 PyErr_SetString (PyExc_ValueError
,
607 _("Search range is empty."));
610 /* Watch for overflows. */
611 else if (length
> CORE_ADDR_MAX
612 || (start_addr
+ length
- 1) < start_addr
)
614 PyErr_SetString (PyExc_ValueError
,
615 _("The search range is too large."));
623 if (!PyObject_CheckReadBuffer (pattern
))
625 PyErr_SetString (PyExc_RuntimeError
,
626 _("The pattern is not a Python buffer."));
631 if (PyObject_AsReadBuffer (pattern
, &buffer
, &pattern_size
) == -1)
634 TRY_CATCH (except
, RETURN_MASK_ALL
)
636 found
= target_search_memory (start_addr
, length
,
637 buffer
, pattern_size
,
640 GDB_PY_HANDLE_EXCEPTION (except
);
643 return PyLong_FromLong (found_addr
);
648 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
649 Returns True if this inferior object still exists in GDB. */
652 infpy_is_valid (PyObject
*self
, PyObject
*args
)
654 inferior_object
*inf
= (inferior_object
*) self
;
663 infpy_dealloc (PyObject
*obj
)
665 inferior_object
*inf_obj
= (inferior_object
*) obj
;
666 struct inferior
*inf
= inf_obj
->inferior
;
671 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
674 /* Clear the INFERIOR pointer in an Inferior object and clear the
677 py_free_inferior (struct inferior
*inf
, void *datum
)
680 struct cleanup
*cleanup
;
681 inferior_object
*inf_obj
= datum
;
682 struct threadlist_entry
*th_entry
, *th_tmp
;
684 cleanup
= ensure_python_env (python_gdbarch
, python_language
);
686 inf_obj
->inferior
= NULL
;
688 /* Deallocate threads list. */
689 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
691 Py_DECREF (th_entry
->thread_obj
);
694 th_entry
= th_entry
->next
;
698 inf_obj
->nthreads
= 0;
700 Py_DECREF ((PyObject
*) inf_obj
);
701 do_cleanups (cleanup
);
704 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
705 Returns the current inferior object. */
708 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
712 inf_obj
= inferior_to_inferior_object (current_inferior ());
719 gdbpy_initialize_inferior (void)
721 if (PyType_Ready (&inferior_object_type
) < 0)
724 Py_INCREF (&inferior_object_type
);
725 PyModule_AddObject (gdb_module
, "Inferior",
726 (PyObject
*) &inferior_object_type
);
729 register_inferior_data_with_cleanup (py_free_inferior
);
731 observer_attach_new_thread (add_thread_object
);
732 observer_attach_thread_exit (delete_thread_object
);
733 observer_attach_normal_stop (python_on_normal_stop
);
734 observer_attach_target_resumed (python_on_resume
);
735 observer_attach_inferior_exit (python_inferior_exit
);
736 observer_attach_new_objfile (python_new_objfile
);
738 membuf_object_type
.tp_new
= PyType_GenericNew
;
739 if (PyType_Ready (&membuf_object_type
) < 0)
742 Py_INCREF (&membuf_object_type
);
743 PyModule_AddObject (gdb_module
, "Membuf", (PyObject
*)
744 &membuf_object_type
);
747 static PyGetSetDef inferior_object_getset
[] =
749 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
750 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
752 { "was_attached", infpy_get_was_attached
, NULL
,
753 "True if the inferior was created using 'attach'.", NULL
},
757 static PyMethodDef inferior_object_methods
[] =
759 { "is_valid", infpy_is_valid
, METH_NOARGS
,
760 "is_valid () -> Boolean.\n\
761 Return true if this inferior is valid, false if not." },
762 { "threads", infpy_threads
, METH_NOARGS
,
763 "Return all the threads of this inferior." },
764 { "read_memory", (PyCFunction
) infpy_read_memory
,
765 METH_VARARGS
| METH_KEYWORDS
,
766 "read_memory (address, length) -> buffer\n\
767 Return a buffer object for reading from the inferior's memory." },
768 { "write_memory", (PyCFunction
) infpy_write_memory
,
769 METH_VARARGS
| METH_KEYWORDS
,
770 "write_memory (address, buffer [, length])\n\
771 Write the given buffer object to the inferior's memory." },
772 { "search_memory", (PyCFunction
) infpy_search_memory
,
773 METH_VARARGS
| METH_KEYWORDS
,
774 "search_memory (address, length, pattern) -> long\n\
775 Return a long with the address of a match, or None." },
779 static PyTypeObject inferior_object_type
=
781 PyObject_HEAD_INIT (NULL
)
783 "gdb.Inferior", /* tp_name */
784 sizeof (inferior_object
), /* tp_basicsize */
786 infpy_dealloc
, /* tp_dealloc */
792 0, /* tp_as_number */
793 0, /* tp_as_sequence */
794 0, /* tp_as_mapping */
800 0, /* tp_as_buffer */
801 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
802 "GDB inferior object", /* tp_doc */
805 0, /* tp_richcompare */
806 0, /* tp_weaklistoffset */
809 inferior_object_methods
, /* tp_methods */
811 inferior_object_getset
, /* tp_getset */
814 0, /* tp_descr_get */
815 0, /* tp_descr_set */
816 0, /* tp_dictoffset */
821 /* Python doesn't provide a decent way to get compatibility here. */
822 #if HAVE_LIBPYTHON2_4
823 #define CHARBUFFERPROC_NAME getcharbufferproc
825 #define CHARBUFFERPROC_NAME charbufferproc
828 static PyBufferProcs buffer_procs
= {
832 /* The cast here works around a difference between Python 2.4 and
834 (CHARBUFFERPROC_NAME
) get_char_buffer
837 static PyTypeObject membuf_object_type
= {
838 PyObject_HEAD_INIT (NULL
)
840 "gdb.Membuf", /*tp_name*/
841 sizeof (membuf_object
), /*tp_basicsize*/
843 mbpy_dealloc
, /*tp_dealloc*/
850 0, /*tp_as_sequence*/
857 &buffer_procs
, /*tp_as_buffer*/
858 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
859 "GDB memory buffer object", /*tp_doc*/
862 0, /* tp_richcompare */
863 0, /* tp_weaklistoffset */
871 0, /* tp_descr_get */
872 0, /* tp_descr_set */
873 0, /* tp_dictoffset */