1 /* Python interface to inferiors.
3 Copyright (C) 2009-2019 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
;
38 struct inferior_object
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 (inferior_ptid
== null_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. */
212 inferior_to_inferior_object (struct inferior
*inferior
)
214 inferior_object
*inf_obj
;
216 inf_obj
= (inferior_object
*) inferior_data (inferior
, infpy_inf_data_key
);
219 inf_obj
= PyObject_New (inferior_object
, &inferior_object_type
);
223 inf_obj
->inferior
= inferior
;
224 inf_obj
->threads
= NULL
;
225 inf_obj
->nthreads
= 0;
227 /* PyObject_New initializes the new object with a refcount of 1. This
228 counts for the reference we are keeping in the inferior data. */
229 set_inferior_data (inferior
, infpy_inf_data_key
, inf_obj
);
233 /* We are returning a new reference. */
234 Py_INCREF ((PyObject
*)inf_obj
);
239 /* Called when a new inferior is created. Notifies any Python event
242 python_new_inferior (struct inferior
*inf
)
244 if (!gdb_python_initialized
)
247 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
249 if (evregpy_no_listeners_p (gdb_py_events
.new_inferior
))
252 gdbpy_ref
<inferior_object
> inf_obj (inferior_to_inferior_object (inf
));
255 gdbpy_print_stack ();
259 gdbpy_ref
<> event
= create_event_object (&new_inferior_event_object_type
);
261 || evpy_add_attribute (event
.get (), "inferior",
262 (PyObject
*) inf_obj
.get ()) < 0
263 || evpy_emit_event (event
.get (), gdb_py_events
.new_inferior
) < 0)
264 gdbpy_print_stack ();
267 /* Called when an inferior is removed. Notifies any Python event
270 python_inferior_deleted (struct inferior
*inf
)
272 if (!gdb_python_initialized
)
275 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
277 if (evregpy_no_listeners_p (gdb_py_events
.inferior_deleted
))
280 gdbpy_ref
<inferior_object
> inf_obj (inferior_to_inferior_object (inf
));
283 gdbpy_print_stack ();
287 gdbpy_ref
<> event
= create_event_object (&inferior_deleted_event_object_type
);
289 || evpy_add_attribute (event
.get (), "inferior",
290 (PyObject
*) inf_obj
.get ()) < 0
291 || evpy_emit_event (event
.get (), gdb_py_events
.inferior_deleted
) < 0)
292 gdbpy_print_stack ();
296 thread_to_thread_object (thread_info
*thr
)
298 gdbpy_ref
<inferior_object
> inf_obj (inferior_to_inferior_object (thr
->inf
));
302 for (threadlist_entry
*thread
= inf_obj
->threads
;
304 thread
= thread
->next
)
305 if (thread
->thread_obj
->thread
== thr
)
306 return gdbpy_ref
<>::new_reference ((PyObject
*) thread
->thread_obj
);
308 PyErr_SetString (PyExc_SystemError
,
309 _("could not find gdb thread object"));
314 add_thread_object (struct thread_info
*tp
)
316 thread_object
*thread_obj
;
317 inferior_object
*inf_obj
;
318 struct threadlist_entry
*entry
;
320 if (!gdb_python_initialized
)
323 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
325 thread_obj
= create_thread_object (tp
);
328 gdbpy_print_stack ();
332 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
334 entry
= XNEW (struct threadlist_entry
);
335 entry
->thread_obj
= thread_obj
;
336 entry
->next
= inf_obj
->threads
;
338 inf_obj
->threads
= entry
;
341 if (evregpy_no_listeners_p (gdb_py_events
.new_thread
))
344 gdbpy_ref
<> event
= create_thread_event_object (&new_thread_event_object_type
,
345 (PyObject
*) thread_obj
);
347 || evpy_emit_event (event
.get (), gdb_py_events
.new_thread
) < 0)
348 gdbpy_print_stack ();
352 delete_thread_object (struct thread_info
*tp
, int ignore
)
354 struct threadlist_entry
**entry
, *tmp
;
356 if (!gdb_python_initialized
)
359 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
361 gdbpy_ref
<inferior_object
> inf_obj
362 ((inferior_object
*) inferior_to_inferior_object (tp
->inf
));
366 /* Find thread entry in its inferior's thread_list. */
367 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
369 if ((*entry
)->thread_obj
->thread
== tp
)
376 tmp
->thread_obj
->thread
= NULL
;
378 *entry
= (*entry
)->next
;
381 Py_DECREF (tmp
->thread_obj
);
386 infpy_threads (PyObject
*self
, PyObject
*args
)
389 struct threadlist_entry
*entry
;
390 inferior_object
*inf_obj
= (inferior_object
*) self
;
393 INFPY_REQUIRE_VALID (inf_obj
);
397 update_thread_list ();
399 CATCH (except
, RETURN_MASK_ALL
)
401 GDB_PY_HANDLE_EXCEPTION (except
);
405 tuple
= PyTuple_New (inf_obj
->nthreads
);
409 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
410 i
++, entry
= entry
->next
)
412 Py_INCREF (entry
->thread_obj
);
413 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
420 infpy_get_num (PyObject
*self
, void *closure
)
422 inferior_object
*inf
= (inferior_object
*) self
;
424 INFPY_REQUIRE_VALID (inf
);
426 return PyLong_FromLong (inf
->inferior
->num
);
430 infpy_get_pid (PyObject
*self
, void *closure
)
432 inferior_object
*inf
= (inferior_object
*) self
;
434 INFPY_REQUIRE_VALID (inf
);
436 return PyLong_FromLong (inf
->inferior
->pid
);
440 infpy_get_was_attached (PyObject
*self
, void *closure
)
442 inferior_object
*inf
= (inferior_object
*) self
;
444 INFPY_REQUIRE_VALID (inf
);
445 if (inf
->inferior
->attach_flag
)
450 /* Getter of gdb.Inferior.progspace. */
453 infpy_get_progspace (PyObject
*self
, void *closure
)
455 inferior_object
*inf
= (inferior_object
*) self
;
457 INFPY_REQUIRE_VALID (inf
);
459 program_space
*pspace
= inf
->inferior
->pspace
;
460 gdb_assert (pspace
!= nullptr);
462 return pspace_to_pspace_object (pspace
).release ();
466 build_inferior_list (struct inferior
*inf
, void *arg
)
468 PyObject
*list
= (PyObject
*) arg
;
469 gdbpy_ref
<inferior_object
> inferior (inferior_to_inferior_object (inf
));
471 if (inferior
== NULL
)
474 return PyList_Append (list
, (PyObject
*) 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::unique_xmalloc_ptr
<gdb_byte
> buffer
;
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
.reset ((gdb_byte
*) xmalloc (length
));
518 read_memory (addr
, buffer
.get (), length
);
520 CATCH (except
, RETURN_MASK_ALL
)
522 GDB_PY_HANDLE_EXCEPTION (except
);
526 gdbpy_ref
<membuf_object
> membuf_obj (PyObject_New (membuf_object
,
527 &membuf_object_type
));
528 if (membuf_obj
== NULL
)
531 membuf_obj
->buffer
= buffer
.release ();
532 membuf_obj
->addr
= addr
;
533 membuf_obj
->length
= length
;
536 result
= PyMemoryView_FromObject ((PyObject
*) membuf_obj
.get ());
538 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
.get (), 0,
545 /* Implementation of Inferior.write_memory (address, buffer [, length]).
546 Writes the contents of BUFFER (a Python object supporting the read
547 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
548 bytes from BUFFER, or its entire contents if the argument is not
549 provided. The function returns nothing. Returns NULL on error, with
550 a python exception set. */
552 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
554 struct gdb_exception except
= exception_none
;
556 const gdb_byte
*buffer
;
557 CORE_ADDR addr
, length
;
558 PyObject
*addr_obj
, *length_obj
= NULL
;
559 static const char *keywords
[] = { "address", "buffer", "length", NULL
};
563 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "Os*|O", keywords
,
564 &addr_obj
, &pybuf
, &length_obj
))
567 buffer
= (const gdb_byte
*) pybuf
.buf
;
570 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "Os#|O", keywords
,
571 &addr_obj
, &buffer
, &buf_len
,
575 buffer
= (const gdb_byte
*) buffer
;
578 if (get_addr_from_python (addr_obj
, &addr
) < 0)
583 else if (get_addr_from_python (length_obj
, &length
) < 0)
588 write_memory_with_notification (addr
, buffer
, length
);
590 CATCH (ex
, RETURN_MASK_ALL
)
597 PyBuffer_Release (&pybuf
);
599 GDB_PY_HANDLE_EXCEPTION (except
);
605 PyBuffer_Release (&pybuf
);
610 /* Destructor of Membuf objects. */
612 mbpy_dealloc (PyObject
*self
)
614 xfree (((membuf_object
*) self
)->buffer
);
615 Py_TYPE (self
)->tp_free (self
);
618 /* Return a description of the Membuf object. */
620 mbpy_str (PyObject
*self
)
622 membuf_object
*membuf_obj
= (membuf_object
*) self
;
624 return PyString_FromFormat (_("Memory buffer for address %s, \
625 which is %s bytes long."),
626 paddress (python_gdbarch
, membuf_obj
->addr
),
627 pulongest (membuf_obj
->length
));
633 get_buffer (PyObject
*self
, Py_buffer
*buf
, int flags
)
635 membuf_object
*membuf_obj
= (membuf_object
*) self
;
638 ret
= PyBuffer_FillInfo (buf
, self
, membuf_obj
->buffer
,
639 membuf_obj
->length
, 0,
642 /* Despite the documentation saying this field is a "const char *",
643 in Python 3.4 at least, it's really a "char *". */
644 buf
->format
= (char *) "c";
652 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
654 membuf_object
*membuf_obj
= (membuf_object
*) self
;
658 PyErr_SetString (PyExc_SystemError
,
659 _("The memory buffer supports only one segment."));
663 *ptrptr
= membuf_obj
->buffer
;
665 return membuf_obj
->length
;
669 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
671 return get_read_buffer (self
, segment
, ptrptr
);
675 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
678 *lenp
= ((membuf_object
*) self
)->length
;
684 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
689 ret
= get_read_buffer (self
, segment
, &ptr
);
690 *ptrptr
= (char *) ptr
;
698 gdb.search_memory (address, length, pattern). ADDRESS is the
699 address to start the search. LENGTH specifies the scope of the
700 search from ADDRESS. PATTERN is the pattern to search for (and
701 must be a Python object supporting the buffer protocol).
702 Returns a Python Long object holding the address where the pattern
703 was located, or if the pattern was not found, returns None. Returns NULL
704 on error, with a python exception set. */
706 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
708 struct gdb_exception except
= exception_none
;
709 CORE_ADDR start_addr
, length
;
710 static const char *keywords
[] = { "address", "length", "pattern", NULL
};
711 PyObject
*start_addr_obj
, *length_obj
;
712 Py_ssize_t pattern_size
;
713 const gdb_byte
*buffer
;
714 CORE_ADDR found_addr
;
719 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OOs*", keywords
,
720 &start_addr_obj
, &length_obj
,
724 buffer
= (const gdb_byte
*) pybuf
.buf
;
725 pattern_size
= pybuf
.len
;
730 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OOO", keywords
,
731 &start_addr_obj
, &length_obj
,
735 if (!PyObject_CheckReadBuffer (pattern
))
737 PyErr_SetString (PyExc_RuntimeError
,
738 _("The pattern is not a Python buffer."));
743 if (PyObject_AsReadBuffer (pattern
, &vbuffer
, &pattern_size
) == -1)
746 buffer
= (const gdb_byte
*) vbuffer
;
749 if (get_addr_from_python (start_addr_obj
, &start_addr
) < 0)
752 if (get_addr_from_python (length_obj
, &length
) < 0)
757 PyErr_SetString (PyExc_ValueError
,
758 _("Search range is empty."));
761 /* Watch for overflows. */
762 else if (length
> CORE_ADDR_MAX
763 || (start_addr
+ length
- 1) < start_addr
)
765 PyErr_SetString (PyExc_ValueError
,
766 _("The search range is too large."));
772 found
= target_search_memory (start_addr
, length
,
773 buffer
, pattern_size
,
776 CATCH (ex
, RETURN_MASK_ALL
)
783 PyBuffer_Release (&pybuf
);
785 GDB_PY_HANDLE_EXCEPTION (except
);
788 return PyLong_FromLong (found_addr
);
794 PyBuffer_Release (&pybuf
);
799 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
800 Returns True if this inferior object still exists in GDB. */
803 infpy_is_valid (PyObject
*self
, PyObject
*args
)
805 inferior_object
*inf
= (inferior_object
*) self
;
813 /* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
814 -> gdb.InferiorThread. */
817 infpy_thread_from_thread_handle (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
819 PyObject
*handle_obj
;
820 inferior_object
*inf_obj
= (inferior_object
*) self
;
821 static const char *keywords
[] = { "thread_handle", NULL
};
823 INFPY_REQUIRE_VALID (inf_obj
);
825 if (! gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "O", keywords
, &handle_obj
))
828 if (!gdbpy_is_value_object (handle_obj
))
830 PyErr_SetString (PyExc_TypeError
,
831 _("Argument 'handle_obj' must be a thread handle object."));
838 struct thread_info
*thread_info
;
839 struct value
*val
= value_object_to_value (handle_obj
);
841 thread_info
= find_thread_by_handle (val
, inf_obj
->inferior
);
842 if (thread_info
!= NULL
)
843 return thread_to_thread_object (thread_info
).release ();
845 CATCH (except
, RETURN_MASK_ALL
)
847 GDB_PY_HANDLE_EXCEPTION (except
);
854 /* Implementation of gdb.Inferior.architecture. */
857 infpy_architecture (PyObject
*self
, PyObject
*args
)
859 inferior_object
*inf
= (inferior_object
*) self
;
861 INFPY_REQUIRE_VALID (inf
);
863 return gdbarch_to_arch_object (inf
->inferior
->gdbarch
);
866 /* Implement repr() for gdb.Inferior. */
869 infpy_repr (PyObject
*obj
)
871 inferior_object
*self
= (inferior_object
*) obj
;
872 inferior
*inf
= self
->inferior
;
875 return PyString_FromString ("<gdb.Inferior (invalid)>");
877 return PyString_FromFormat ("<gdb.Inferior num=%d, pid=%d>",
883 infpy_dealloc (PyObject
*obj
)
885 inferior_object
*inf_obj
= (inferior_object
*) obj
;
886 struct inferior
*inf
= inf_obj
->inferior
;
891 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
894 /* Clear the INFERIOR pointer in an Inferior object and clear the
897 py_free_inferior (struct inferior
*inf
, void *datum
)
899 gdbpy_ref
<inferior_object
> inf_obj ((inferior_object
*) datum
);
900 struct threadlist_entry
*th_entry
, *th_tmp
;
902 if (!gdb_python_initialized
)
905 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
907 inf_obj
->inferior
= NULL
;
909 /* Deallocate threads list. */
910 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
912 Py_DECREF (th_entry
->thread_obj
);
915 th_entry
= th_entry
->next
;
919 inf_obj
->nthreads
= 0;
922 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
923 Returns the current inferior object. */
926 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
928 return (PyObject
*) inferior_to_inferior_object (current_inferior ());
932 gdbpy_initialize_inferior (void)
934 if (PyType_Ready (&inferior_object_type
) < 0)
937 if (gdb_pymodule_addobject (gdb_module
, "Inferior",
938 (PyObject
*) &inferior_object_type
) < 0)
942 register_inferior_data_with_cleanup (NULL
, py_free_inferior
);
944 gdb::observers::new_thread
.attach (add_thread_object
);
945 gdb::observers::thread_exit
.attach (delete_thread_object
);
946 gdb::observers::normal_stop
.attach (python_on_normal_stop
);
947 gdb::observers::target_resumed
.attach (python_on_resume
);
948 gdb::observers::inferior_call_pre
.attach (python_on_inferior_call_pre
);
949 gdb::observers::inferior_call_post
.attach (python_on_inferior_call_post
);
950 gdb::observers::memory_changed
.attach (python_on_memory_change
);
951 gdb::observers::register_changed
.attach (python_on_register_change
);
952 gdb::observers::inferior_exit
.attach (python_inferior_exit
);
953 gdb::observers::new_objfile
.attach (python_new_objfile
);
954 gdb::observers::inferior_added
.attach (python_new_inferior
);
955 gdb::observers::inferior_removed
.attach (python_inferior_deleted
);
957 membuf_object_type
.tp_new
= PyType_GenericNew
;
958 if (PyType_Ready (&membuf_object_type
) < 0)
961 return gdb_pymodule_addobject (gdb_module
, "Membuf", (PyObject
*)
962 &membuf_object_type
);
965 static gdb_PyGetSetDef inferior_object_getset
[] =
967 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
968 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
970 { "was_attached", infpy_get_was_attached
, NULL
,
971 "True if the inferior was created using 'attach'.", NULL
},
972 { "progspace", infpy_get_progspace
, NULL
, "Program space of this inferior" },
976 static PyMethodDef inferior_object_methods
[] =
978 { "is_valid", infpy_is_valid
, METH_NOARGS
,
979 "is_valid () -> Boolean.\n\
980 Return true if this inferior is valid, false if not." },
981 { "threads", infpy_threads
, METH_NOARGS
,
982 "Return all the threads of this inferior." },
983 { "read_memory", (PyCFunction
) infpy_read_memory
,
984 METH_VARARGS
| METH_KEYWORDS
,
985 "read_memory (address, length) -> buffer\n\
986 Return a buffer object for reading from the inferior's memory." },
987 { "write_memory", (PyCFunction
) infpy_write_memory
,
988 METH_VARARGS
| METH_KEYWORDS
,
989 "write_memory (address, buffer [, length])\n\
990 Write the given buffer object to the inferior's memory." },
991 { "search_memory", (PyCFunction
) infpy_search_memory
,
992 METH_VARARGS
| METH_KEYWORDS
,
993 "search_memory (address, length, pattern) -> long\n\
994 Return a long with the address of a match, or None." },
995 { "thread_from_thread_handle", (PyCFunction
) infpy_thread_from_thread_handle
,
996 METH_VARARGS
| METH_KEYWORDS
,
997 "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
998 Return thread object corresponding to thread handle." },
999 { "architecture", (PyCFunction
) infpy_architecture
, METH_NOARGS
,
1000 "architecture () -> gdb.Architecture\n\
1001 Return architecture of this inferior." },
1005 PyTypeObject inferior_object_type
=
1007 PyVarObject_HEAD_INIT (NULL
, 0)
1008 "gdb.Inferior", /* tp_name */
1009 sizeof (inferior_object
), /* tp_basicsize */
1010 0, /* tp_itemsize */
1011 infpy_dealloc
, /* tp_dealloc */
1016 infpy_repr
, /* tp_repr */
1017 0, /* tp_as_number */
1018 0, /* tp_as_sequence */
1019 0, /* tp_as_mapping */
1023 0, /* tp_getattro */
1024 0, /* tp_setattro */
1025 0, /* tp_as_buffer */
1026 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
1027 "GDB inferior object", /* tp_doc */
1028 0, /* tp_traverse */
1030 0, /* tp_richcompare */
1031 0, /* tp_weaklistoffset */
1033 0, /* tp_iternext */
1034 inferior_object_methods
, /* tp_methods */
1036 inferior_object_getset
, /* tp_getset */
1039 0, /* tp_descr_get */
1040 0, /* tp_descr_set */
1041 0, /* tp_dictoffset */
1048 static PyBufferProcs buffer_procs
=
1055 /* Python doesn't provide a decent way to get compatibility here. */
1056 #if HAVE_LIBPYTHON2_4
1057 #define CHARBUFFERPROC_NAME getcharbufferproc
1059 #define CHARBUFFERPROC_NAME charbufferproc
1062 static PyBufferProcs buffer_procs
= {
1066 /* The cast here works around a difference between Python 2.4 and
1068 (CHARBUFFERPROC_NAME
) get_char_buffer
1070 #endif /* IS_PY3K */
1072 PyTypeObject membuf_object_type
= {
1073 PyVarObject_HEAD_INIT (NULL
, 0)
1074 "gdb.Membuf", /*tp_name*/
1075 sizeof (membuf_object
), /*tp_basicsize*/
1077 mbpy_dealloc
, /*tp_dealloc*/
1084 0, /*tp_as_sequence*/
1085 0, /*tp_as_mapping*/
1088 mbpy_str
, /*tp_str*/
1091 &buffer_procs
, /*tp_as_buffer*/
1092 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1093 "GDB memory buffer object", /*tp_doc*/
1094 0, /* tp_traverse */
1096 0, /* tp_richcompare */
1097 0, /* tp_weaklistoffset */
1099 0, /* tp_iternext */
1105 0, /* tp_descr_get */
1106 0, /* tp_descr_set */
1107 0, /* tp_dictoffset */