1 /* Python interface to inferiors.
3 Copyright (C) 2009-2018 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"
25 #include "observable.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 /* PyObject_New initializes the new object with a refcount of 1. This
227 counts for the reference we are keeping in the inferior data. */
228 set_inferior_data (inferior
, infpy_inf_data_key
, inf_obj
);
232 /* We are returning a new reference. */
233 Py_INCREF ((PyObject
*)inf_obj
);
235 return (PyObject
*) inf_obj
;
238 /* Called when a new inferior is created. Notifies any Python event
241 python_new_inferior (struct inferior
*inf
)
243 if (!gdb_python_initialized
)
246 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
248 if (evregpy_no_listeners_p (gdb_py_events
.new_inferior
))
251 gdbpy_ref
<> inf_obj (inferior_to_inferior_object (inf
));
254 gdbpy_print_stack ();
258 gdbpy_ref
<> event (create_event_object (&new_inferior_event_object_type
));
260 || evpy_add_attribute (event
.get (), "inferior", inf_obj
.get ()) < 0
261 || evpy_emit_event (event
.get (), gdb_py_events
.new_inferior
) < 0)
262 gdbpy_print_stack ();
265 /* Called when an inferior is removed. Notifies any Python event
268 python_inferior_deleted (struct inferior
*inf
)
270 if (!gdb_python_initialized
)
273 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
275 if (evregpy_no_listeners_p (gdb_py_events
.inferior_deleted
))
278 gdbpy_ref
<> inf_obj (inferior_to_inferior_object (inf
));
281 gdbpy_print_stack ();
285 gdbpy_ref
<> event (create_event_object (&inferior_deleted_event_object_type
));
287 || evpy_add_attribute (event
.get (), "inferior", inf_obj
.get ()) < 0
288 || evpy_emit_event (event
.get (), gdb_py_events
.inferior_deleted
) < 0)
289 gdbpy_print_stack ();
292 /* Finds the Python Inferior object for the given PID. Returns a
293 reference, or NULL if PID does not match any inferior object. */
296 find_inferior_object (int pid
)
298 struct inferior
*inf
= find_inferior_pid (pid
);
301 return inferior_to_inferior_object (inf
);
307 find_thread_object (ptid_t ptid
)
310 struct threadlist_entry
*thread
;
312 pid
= ptid_get_pid (ptid
);
316 gdbpy_ref
<> inf_obj (find_inferior_object (pid
));
320 for (thread
= ((inferior_object
*)(inf_obj
.get ()))->threads
; thread
;
321 thread
= thread
->next
)
322 if (ptid_equal (thread
->thread_obj
->thread
->ptid
, ptid
))
323 return thread
->thread_obj
;
329 add_thread_object (struct thread_info
*tp
)
331 thread_object
*thread_obj
;
332 inferior_object
*inf_obj
;
333 struct threadlist_entry
*entry
;
335 if (!gdb_python_initialized
)
338 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
340 thread_obj
= create_thread_object (tp
);
343 gdbpy_print_stack ();
347 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
349 entry
= XNEW (struct threadlist_entry
);
350 entry
->thread_obj
= thread_obj
;
351 entry
->next
= inf_obj
->threads
;
353 inf_obj
->threads
= entry
;
356 if (evregpy_no_listeners_p (gdb_py_events
.new_thread
))
359 gdbpy_ref
<> event (create_thread_event_object (&new_thread_event_object_type
,
360 (PyObject
*) thread_obj
));
362 || evpy_emit_event (event
.get (), gdb_py_events
.new_thread
) < 0)
363 gdbpy_print_stack ();
367 delete_thread_object (struct thread_info
*tp
, int ignore
)
369 struct threadlist_entry
**entry
, *tmp
;
371 if (!gdb_python_initialized
)
374 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
376 gdbpy_ref
<inferior_object
> inf_obj
377 ((inferior_object
*) find_inferior_object (ptid_get_pid (tp
->ptid
)));
381 /* Find thread entry in its inferior's thread_list. */
382 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
384 if ((*entry
)->thread_obj
->thread
== tp
)
391 tmp
->thread_obj
->thread
= NULL
;
393 *entry
= (*entry
)->next
;
396 Py_DECREF (tmp
->thread_obj
);
401 infpy_threads (PyObject
*self
, PyObject
*args
)
404 struct threadlist_entry
*entry
;
405 inferior_object
*inf_obj
= (inferior_object
*) self
;
408 INFPY_REQUIRE_VALID (inf_obj
);
412 update_thread_list ();
414 CATCH (except
, RETURN_MASK_ALL
)
416 GDB_PY_HANDLE_EXCEPTION (except
);
420 tuple
= PyTuple_New (inf_obj
->nthreads
);
424 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
425 i
++, entry
= entry
->next
)
427 Py_INCREF (entry
->thread_obj
);
428 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
435 infpy_get_num (PyObject
*self
, void *closure
)
437 inferior_object
*inf
= (inferior_object
*) self
;
439 INFPY_REQUIRE_VALID (inf
);
441 return PyLong_FromLong (inf
->inferior
->num
);
445 infpy_get_pid (PyObject
*self
, void *closure
)
447 inferior_object
*inf
= (inferior_object
*) self
;
449 INFPY_REQUIRE_VALID (inf
);
451 return PyLong_FromLong (inf
->inferior
->pid
);
455 infpy_get_was_attached (PyObject
*self
, void *closure
)
457 inferior_object
*inf
= (inferior_object
*) self
;
459 INFPY_REQUIRE_VALID (inf
);
460 if (inf
->inferior
->attach_flag
)
466 build_inferior_list (struct inferior
*inf
, void *arg
)
468 PyObject
*list
= (PyObject
*) arg
;
469 gdbpy_ref
<> inferior (inferior_to_inferior_object (inf
));
471 if (inferior
== NULL
)
474 return PyList_Append (list
, inferior
.get ()) ? 1 : 0;
477 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
478 Returns a tuple of all inferiors. */
480 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
482 gdbpy_ref
<> list (PyList_New (0));
486 if (iterate_over_inferiors (build_inferior_list
, list
.get ()))
489 return PyList_AsTuple (list
.get ());
492 /* Membuf and memory manipulation. */
494 /* Implementation of Inferior.read_memory (address, length).
495 Returns a Python buffer object with LENGTH bytes of the inferior's
496 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
497 with a python exception set. */
499 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
501 CORE_ADDR addr
, length
;
502 gdb_byte
*buffer
= NULL
;
503 PyObject
*addr_obj
, *length_obj
, *result
;
504 static const char *keywords
[] = { "address", "length", NULL
};
506 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
507 &addr_obj
, &length_obj
))
510 if (get_addr_from_python (addr_obj
, &addr
) < 0
511 || get_addr_from_python (length_obj
, &length
) < 0)
516 buffer
= (gdb_byte
*) xmalloc (length
);
518 read_memory (addr
, buffer
, length
);
520 CATCH (except
, RETURN_MASK_ALL
)
523 GDB_PY_HANDLE_EXCEPTION (except
);
527 gdbpy_ref
<membuf_object
> membuf_obj (PyObject_New (membuf_object
,
528 &membuf_object_type
));
529 if (membuf_obj
== NULL
)
535 membuf_obj
->buffer
= buffer
;
536 membuf_obj
->addr
= addr
;
537 membuf_obj
->length
= length
;
540 result
= PyMemoryView_FromObject ((PyObject
*) membuf_obj
.get ());
542 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
.get (), 0,
549 /* Implementation of Inferior.write_memory (address, buffer [, length]).
550 Writes the contents of BUFFER (a Python object supporting the read
551 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
552 bytes from BUFFER, or its entire contents if the argument is not
553 provided. The function returns nothing. Returns NULL on error, with
554 a python exception set. */
556 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
558 struct gdb_exception except
= exception_none
;
560 const gdb_byte
*buffer
;
561 CORE_ADDR addr
, length
;
562 PyObject
*addr_obj
, *length_obj
= NULL
;
563 static const char *keywords
[] = { "address", "buffer", "length", NULL
};
567 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "Os*|O", keywords
,
568 &addr_obj
, &pybuf
, &length_obj
))
571 buffer
= (const gdb_byte
*) pybuf
.buf
;
574 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "Os#|O", keywords
,
575 &addr_obj
, &buffer
, &buf_len
,
579 buffer
= (const gdb_byte
*) buffer
;
582 if (get_addr_from_python (addr_obj
, &addr
) < 0)
587 else if (get_addr_from_python (length_obj
, &length
) < 0)
592 write_memory_with_notification (addr
, buffer
, length
);
594 CATCH (ex
, RETURN_MASK_ALL
)
601 PyBuffer_Release (&pybuf
);
603 GDB_PY_HANDLE_EXCEPTION (except
);
609 PyBuffer_Release (&pybuf
);
614 /* Destructor of Membuf objects. */
616 mbpy_dealloc (PyObject
*self
)
618 xfree (((membuf_object
*) self
)->buffer
);
619 Py_TYPE (self
)->tp_free (self
);
622 /* Return a description of the Membuf object. */
624 mbpy_str (PyObject
*self
)
626 membuf_object
*membuf_obj
= (membuf_object
*) self
;
628 return PyString_FromFormat (_("Memory buffer for address %s, \
629 which is %s bytes long."),
630 paddress (python_gdbarch
, membuf_obj
->addr
),
631 pulongest (membuf_obj
->length
));
637 get_buffer (PyObject
*self
, Py_buffer
*buf
, int flags
)
639 membuf_object
*membuf_obj
= (membuf_object
*) self
;
642 ret
= PyBuffer_FillInfo (buf
, self
, membuf_obj
->buffer
,
643 membuf_obj
->length
, 0,
646 /* Despite the documentation saying this field is a "const char *",
647 in Python 3.4 at least, it's really a "char *". */
648 buf
->format
= (char *) "c";
656 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
658 membuf_object
*membuf_obj
= (membuf_object
*) self
;
662 PyErr_SetString (PyExc_SystemError
,
663 _("The memory buffer supports only one segment."));
667 *ptrptr
= membuf_obj
->buffer
;
669 return membuf_obj
->length
;
673 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
675 return get_read_buffer (self
, segment
, ptrptr
);
679 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
682 *lenp
= ((membuf_object
*) self
)->length
;
688 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
693 ret
= get_read_buffer (self
, segment
, &ptr
);
694 *ptrptr
= (char *) ptr
;
702 gdb.search_memory (address, length, pattern). ADDRESS is the
703 address to start the search. LENGTH specifies the scope of the
704 search from ADDRESS. PATTERN is the pattern to search for (and
705 must be a Python object supporting the buffer protocol).
706 Returns a Python Long object holding the address where the pattern
707 was located, or if the pattern was not found, returns None. Returns NULL
708 on error, with a python exception set. */
710 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
712 struct gdb_exception except
= exception_none
;
713 CORE_ADDR start_addr
, length
;
714 static const char *keywords
[] = { "address", "length", "pattern", NULL
};
715 PyObject
*start_addr_obj
, *length_obj
;
716 Py_ssize_t pattern_size
;
717 const gdb_byte
*buffer
;
718 CORE_ADDR found_addr
;
723 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OOs*", keywords
,
724 &start_addr_obj
, &length_obj
,
728 buffer
= (const gdb_byte
*) pybuf
.buf
;
729 pattern_size
= pybuf
.len
;
734 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OOO", keywords
,
735 &start_addr_obj
, &length_obj
,
739 if (!PyObject_CheckReadBuffer (pattern
))
741 PyErr_SetString (PyExc_RuntimeError
,
742 _("The pattern is not a Python buffer."));
747 if (PyObject_AsReadBuffer (pattern
, &vbuffer
, &pattern_size
) == -1)
750 buffer
= (const gdb_byte
*) vbuffer
;
753 if (get_addr_from_python (start_addr_obj
, &start_addr
) < 0)
756 if (get_addr_from_python (length_obj
, &length
) < 0)
761 PyErr_SetString (PyExc_ValueError
,
762 _("Search range is empty."));
765 /* Watch for overflows. */
766 else if (length
> CORE_ADDR_MAX
767 || (start_addr
+ length
- 1) < start_addr
)
769 PyErr_SetString (PyExc_ValueError
,
770 _("The search range is too large."));
776 found
= target_search_memory (start_addr
, length
,
777 buffer
, pattern_size
,
780 CATCH (ex
, RETURN_MASK_ALL
)
787 PyBuffer_Release (&pybuf
);
789 GDB_PY_HANDLE_EXCEPTION (except
);
792 return PyLong_FromLong (found_addr
);
798 PyBuffer_Release (&pybuf
);
803 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
804 Returns True if this inferior object still exists in GDB. */
807 infpy_is_valid (PyObject
*self
, PyObject
*args
)
809 inferior_object
*inf
= (inferior_object
*) self
;
817 /* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
818 -> gdb.InferiorThread. */
821 infpy_thread_from_thread_handle (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
823 PyObject
*handle_obj
, *result
;
824 inferior_object
*inf_obj
= (inferior_object
*) self
;
825 static const char *keywords
[] = { "thread_handle", NULL
};
827 INFPY_REQUIRE_VALID (inf_obj
);
829 if (! gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "O", keywords
, &handle_obj
))
834 if (!gdbpy_is_value_object (handle_obj
))
836 PyErr_SetString (PyExc_TypeError
,
837 _("Argument 'handle_obj' must be a thread handle object."));
845 struct thread_info
*thread_info
;
846 struct value
*val
= value_object_to_value (handle_obj
);
848 thread_info
= find_thread_by_handle (val
, inf_obj
->inferior
);
849 if (thread_info
!= NULL
)
851 result
= (PyObject
*) find_thread_object (thread_info
->ptid
);
856 CATCH (except
, RETURN_MASK_ALL
)
858 GDB_PY_HANDLE_EXCEPTION (except
);
868 infpy_dealloc (PyObject
*obj
)
870 inferior_object
*inf_obj
= (inferior_object
*) obj
;
871 struct inferior
*inf
= inf_obj
->inferior
;
876 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
879 /* Clear the INFERIOR pointer in an Inferior object and clear the
882 py_free_inferior (struct inferior
*inf
, void *datum
)
884 gdbpy_ref
<inferior_object
> inf_obj ((inferior_object
*) datum
);
885 struct threadlist_entry
*th_entry
, *th_tmp
;
887 if (!gdb_python_initialized
)
890 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
892 inf_obj
->inferior
= NULL
;
894 /* Deallocate threads list. */
895 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
897 Py_DECREF (th_entry
->thread_obj
);
900 th_entry
= th_entry
->next
;
904 inf_obj
->nthreads
= 0;
907 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
908 Returns the current inferior object. */
911 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
913 return inferior_to_inferior_object (current_inferior ());
917 gdbpy_initialize_inferior (void)
919 if (PyType_Ready (&inferior_object_type
) < 0)
922 if (gdb_pymodule_addobject (gdb_module
, "Inferior",
923 (PyObject
*) &inferior_object_type
) < 0)
927 register_inferior_data_with_cleanup (NULL
, py_free_inferior
);
929 gdb::observers::new_thread
.attach (add_thread_object
);
930 gdb::observers::thread_exit
.attach (delete_thread_object
);
931 gdb::observers::normal_stop
.attach (python_on_normal_stop
);
932 gdb::observers::target_resumed
.attach (python_on_resume
);
933 gdb::observers::inferior_call_pre
.attach (python_on_inferior_call_pre
);
934 gdb::observers::inferior_call_post
.attach (python_on_inferior_call_post
);
935 gdb::observers::memory_changed
.attach (python_on_memory_change
);
936 gdb::observers::register_changed
.attach (python_on_register_change
);
937 gdb::observers::inferior_exit
.attach (python_inferior_exit
);
938 gdb::observers::new_objfile
.attach (python_new_objfile
);
939 gdb::observers::inferior_added
.attach (python_new_inferior
);
940 gdb::observers::inferior_removed
.attach (python_inferior_deleted
);
942 membuf_object_type
.tp_new
= PyType_GenericNew
;
943 if (PyType_Ready (&membuf_object_type
) < 0)
946 return gdb_pymodule_addobject (gdb_module
, "Membuf", (PyObject
*)
947 &membuf_object_type
);
950 static gdb_PyGetSetDef inferior_object_getset
[] =
952 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
953 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
955 { "was_attached", infpy_get_was_attached
, NULL
,
956 "True if the inferior was created using 'attach'.", NULL
},
960 static PyMethodDef inferior_object_methods
[] =
962 { "is_valid", infpy_is_valid
, METH_NOARGS
,
963 "is_valid () -> Boolean.\n\
964 Return true if this inferior is valid, false if not." },
965 { "threads", infpy_threads
, METH_NOARGS
,
966 "Return all the threads of this inferior." },
967 { "read_memory", (PyCFunction
) infpy_read_memory
,
968 METH_VARARGS
| METH_KEYWORDS
,
969 "read_memory (address, length) -> buffer\n\
970 Return a buffer object for reading from the inferior's memory." },
971 { "write_memory", (PyCFunction
) infpy_write_memory
,
972 METH_VARARGS
| METH_KEYWORDS
,
973 "write_memory (address, buffer [, length])\n\
974 Write the given buffer object to the inferior's memory." },
975 { "search_memory", (PyCFunction
) infpy_search_memory
,
976 METH_VARARGS
| METH_KEYWORDS
,
977 "search_memory (address, length, pattern) -> long\n\
978 Return a long with the address of a match, or None." },
979 { "thread_from_thread_handle", (PyCFunction
) infpy_thread_from_thread_handle
,
980 METH_VARARGS
| METH_KEYWORDS
,
981 "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
982 Return thread object corresponding to thread handle." },
986 PyTypeObject inferior_object_type
=
988 PyVarObject_HEAD_INIT (NULL
, 0)
989 "gdb.Inferior", /* tp_name */
990 sizeof (inferior_object
), /* tp_basicsize */
992 infpy_dealloc
, /* tp_dealloc */
998 0, /* tp_as_number */
999 0, /* tp_as_sequence */
1000 0, /* tp_as_mapping */
1004 0, /* tp_getattro */
1005 0, /* tp_setattro */
1006 0, /* tp_as_buffer */
1007 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
1008 "GDB inferior object", /* tp_doc */
1009 0, /* tp_traverse */
1011 0, /* tp_richcompare */
1012 0, /* tp_weaklistoffset */
1014 0, /* tp_iternext */
1015 inferior_object_methods
, /* tp_methods */
1017 inferior_object_getset
, /* tp_getset */
1020 0, /* tp_descr_get */
1021 0, /* tp_descr_set */
1022 0, /* tp_dictoffset */
1029 static PyBufferProcs buffer_procs
=
1036 /* Python doesn't provide a decent way to get compatibility here. */
1037 #if HAVE_LIBPYTHON2_4
1038 #define CHARBUFFERPROC_NAME getcharbufferproc
1040 #define CHARBUFFERPROC_NAME charbufferproc
1043 static PyBufferProcs buffer_procs
= {
1047 /* The cast here works around a difference between Python 2.4 and
1049 (CHARBUFFERPROC_NAME
) get_char_buffer
1051 #endif /* IS_PY3K */
1053 PyTypeObject membuf_object_type
= {
1054 PyVarObject_HEAD_INIT (NULL
, 0)
1055 "gdb.Membuf", /*tp_name*/
1056 sizeof (membuf_object
), /*tp_basicsize*/
1058 mbpy_dealloc
, /*tp_dealloc*/
1065 0, /*tp_as_sequence*/
1066 0, /*tp_as_mapping*/
1069 mbpy_str
, /*tp_str*/
1072 &buffer_procs
, /*tp_as_buffer*/
1073 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1074 "GDB memory buffer object", /*tp_doc*/
1075 0, /* tp_traverse */
1077 0, /* tp_richcompare */
1078 0, /* tp_weaklistoffset */
1080 0, /* tp_iternext */
1086 0, /* tp_descr_get */
1087 0, /* tp_descr_set */
1088 0, /* tp_dictoffset */