1 /* Python interface to inferiors.
3 Copyright (C) 2009-2020 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 "gdbsupport/gdb_signals.h"
31 #include "py-stopevent.h"
33 struct threadlist_entry
35 threadlist_entry (gdbpy_ref
<thread_object
> &&ref
)
36 : thread_obj (std::move (ref
))
40 gdbpy_ref
<thread_object
> thread_obj
;
41 struct threadlist_entry
*next
;
44 struct inferior_object
48 /* The inferior we represent. */
49 struct inferior
*inferior
;
51 /* thread_object instances under this inferior. This list owns a
52 reference to each object it contains. */
53 struct threadlist_entry
*threads
;
55 /* Number of threads in the list. */
59 extern PyTypeObject inferior_object_type
60 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("inferior_object");
62 static const struct inferior_data
*infpy_inf_data_key
;
68 /* These are kept just for mbpy_str. */
73 extern PyTypeObject membuf_object_type
74 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("membuf_object");
76 /* Require that INFERIOR be a valid inferior ID. */
77 #define INFPY_REQUIRE_VALID(Inferior) \
79 if (!Inferior->inferior) \
81 PyErr_SetString (PyExc_RuntimeError, \
82 _("Inferior no longer exists.")); \
88 python_on_normal_stop (struct bpstats
*bs
, int print_frame
)
90 enum gdb_signal stop_signal
;
92 if (!gdb_python_initialized
)
95 if (inferior_ptid
== null_ptid
)
98 stop_signal
= inferior_thread ()->suspend
.stop_signal
;
100 gdbpy_enter
enter_py (get_current_arch (), current_language
);
102 if (emit_stop_event (bs
, stop_signal
) < 0)
103 gdbpy_print_stack ();
107 python_on_resume (ptid_t ptid
)
109 if (!gdb_python_initialized
)
112 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
114 if (emit_continue_event (ptid
) < 0)
115 gdbpy_print_stack ();
118 /* Callback, registered as an observer, that notifies Python listeners
119 when an inferior function call is about to be made. */
122 python_on_inferior_call_pre (ptid_t thread
, CORE_ADDR address
)
124 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
126 if (emit_inferior_call_event (INFERIOR_CALL_PRE
, thread
, address
) < 0)
127 gdbpy_print_stack ();
130 /* Callback, registered as an observer, that notifies Python listeners
131 when an inferior function call has completed. */
134 python_on_inferior_call_post (ptid_t thread
, CORE_ADDR address
)
136 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
138 if (emit_inferior_call_event (INFERIOR_CALL_POST
, thread
, address
) < 0)
139 gdbpy_print_stack ();
142 /* Callback, registered as an observer, that notifies Python listeners
143 when a part of memory has been modified by user action (eg via a
147 python_on_memory_change (struct inferior
*inferior
, CORE_ADDR addr
, ssize_t len
, const bfd_byte
*data
)
149 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
151 if (emit_memory_changed_event (addr
, len
) < 0)
152 gdbpy_print_stack ();
155 /* Callback, registered as an observer, that notifies Python listeners
156 when a register has been modified by user action (eg via a 'set'
160 python_on_register_change (struct frame_info
*frame
, int regnum
)
162 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
164 if (emit_register_changed_event (frame
, regnum
) < 0)
165 gdbpy_print_stack ();
169 python_inferior_exit (struct inferior
*inf
)
171 const LONGEST
*exit_code
= NULL
;
173 if (!gdb_python_initialized
)
176 gdbpy_enter
enter_py (target_gdbarch (), current_language
);
178 if (inf
->has_exit_code
)
179 exit_code
= &inf
->exit_code
;
181 if (emit_exited_event (exit_code
, inf
) < 0)
182 gdbpy_print_stack ();
185 /* Callback used to notify Python listeners about new objfiles loaded in the
186 inferior. OBJFILE may be NULL which means that the objfile list has been
187 cleared (emptied). */
190 python_new_objfile (struct objfile
*objfile
)
192 if (!gdb_python_initialized
)
195 gdbpy_enter
enter_py (objfile
!= NULL
202 if (emit_clear_objfiles_event () < 0)
203 gdbpy_print_stack ();
207 if (emit_new_objfile_event (objfile
) < 0)
208 gdbpy_print_stack ();
212 /* Return a reference to the Python object of type Inferior
213 representing INFERIOR. If the object has already been created,
214 return it and increment the reference count, otherwise, create it.
215 Return NULL on failure. */
217 gdbpy_ref
<inferior_object
>
218 inferior_to_inferior_object (struct inferior
*inferior
)
220 inferior_object
*inf_obj
;
222 inf_obj
= (inferior_object
*) inferior_data (inferior
, infpy_inf_data_key
);
225 inf_obj
= PyObject_New (inferior_object
, &inferior_object_type
);
229 inf_obj
->inferior
= inferior
;
230 inf_obj
->threads
= NULL
;
231 inf_obj
->nthreads
= 0;
233 /* PyObject_New initializes the new object with a refcount of 1. This
234 counts for the reference we are keeping in the inferior data. */
235 set_inferior_data (inferior
, infpy_inf_data_key
, inf_obj
);
238 /* We are returning a new reference. */
239 gdb_assert (inf_obj
!= nullptr);
240 return gdbpy_ref
<inferior_object
>::new_reference (inf_obj
);
243 /* Called when a new inferior is created. Notifies any Python event
246 python_new_inferior (struct inferior
*inf
)
248 if (!gdb_python_initialized
)
251 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
253 if (evregpy_no_listeners_p (gdb_py_events
.new_inferior
))
256 gdbpy_ref
<inferior_object
> inf_obj
= inferior_to_inferior_object (inf
);
259 gdbpy_print_stack ();
263 gdbpy_ref
<> event
= create_event_object (&new_inferior_event_object_type
);
265 || evpy_add_attribute (event
.get (), "inferior",
266 (PyObject
*) inf_obj
.get ()) < 0
267 || evpy_emit_event (event
.get (), gdb_py_events
.new_inferior
) < 0)
268 gdbpy_print_stack ();
271 /* Called when an inferior is removed. Notifies any Python event
274 python_inferior_deleted (struct inferior
*inf
)
276 if (!gdb_python_initialized
)
279 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
281 if (evregpy_no_listeners_p (gdb_py_events
.inferior_deleted
))
284 gdbpy_ref
<inferior_object
> inf_obj
= inferior_to_inferior_object (inf
);
287 gdbpy_print_stack ();
291 gdbpy_ref
<> event
= create_event_object (&inferior_deleted_event_object_type
);
293 || evpy_add_attribute (event
.get (), "inferior",
294 (PyObject
*) inf_obj
.get ()) < 0
295 || evpy_emit_event (event
.get (), gdb_py_events
.inferior_deleted
) < 0)
296 gdbpy_print_stack ();
300 thread_to_thread_object (thread_info
*thr
)
302 gdbpy_ref
<inferior_object
> inf_obj
= inferior_to_inferior_object (thr
->inf
);
306 for (threadlist_entry
*thread
= inf_obj
->threads
;
308 thread
= thread
->next
)
309 if (thread
->thread_obj
->thread
== thr
)
310 return gdbpy_ref
<>::new_reference ((PyObject
*) thread
->thread_obj
.get ());
312 PyErr_SetString (PyExc_SystemError
,
313 _("could not find gdb thread object"));
318 add_thread_object (struct thread_info
*tp
)
320 inferior_object
*inf_obj
;
321 struct threadlist_entry
*entry
;
323 if (!gdb_python_initialized
)
326 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
328 gdbpy_ref
<thread_object
> thread_obj
= create_thread_object (tp
);
329 if (thread_obj
== NULL
)
331 gdbpy_print_stack ();
335 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
337 entry
= new threadlist_entry (std::move (thread_obj
));
338 entry
->next
= inf_obj
->threads
;
340 inf_obj
->threads
= entry
;
343 if (evregpy_no_listeners_p (gdb_py_events
.new_thread
))
346 gdbpy_ref
<> event
= create_thread_event_object (&new_thread_event_object_type
,
347 (PyObject
*) inf_obj
);
349 || evpy_emit_event (event
.get (), gdb_py_events
.new_thread
) < 0)
350 gdbpy_print_stack ();
354 delete_thread_object (struct thread_info
*tp
, int ignore
)
356 struct threadlist_entry
**entry
, *tmp
;
358 if (!gdb_python_initialized
)
361 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
363 gdbpy_ref
<inferior_object
> inf_obj
= inferior_to_inferior_object (tp
->inf
);
367 /* Find thread entry in its inferior's thread_list. */
368 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
370 if ((*entry
)->thread_obj
->thread
== tp
)
377 tmp
->thread_obj
->thread
= NULL
;
379 *entry
= (*entry
)->next
;
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 (const gdb_exception
&except
)
401 GDB_PY_HANDLE_EXCEPTION (except
);
404 tuple
= PyTuple_New (inf_obj
->nthreads
);
408 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
409 i
++, entry
= entry
->next
)
411 PyObject
*thr
= (PyObject
*) entry
->thread_obj
.get ();
413 PyTuple_SET_ITEM (tuple
, i
, thr
);
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 ();
465 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
466 Returns a tuple of all inferiors. */
468 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
470 gdbpy_ref
<> list (PyList_New (0));
474 for (inferior
*inf
: all_inferiors ())
476 gdbpy_ref
<inferior_object
> inferior
= inferior_to_inferior_object (inf
);
478 if (inferior
== NULL
)
481 if (PyList_Append (list
.get (), (PyObject
*) inferior
.get ()) != 0)
485 return PyList_AsTuple (list
.get ());
488 /* Membuf and memory manipulation. */
490 /* Implementation of Inferior.read_memory (address, length).
491 Returns a Python buffer object with LENGTH bytes of the inferior's
492 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
493 with a python exception set. */
495 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
497 CORE_ADDR addr
, length
;
498 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
;
499 PyObject
*addr_obj
, *length_obj
, *result
;
500 static const char *keywords
[] = { "address", "length", NULL
};
502 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
503 &addr_obj
, &length_obj
))
506 if (get_addr_from_python (addr_obj
, &addr
) < 0
507 || get_addr_from_python (length_obj
, &length
) < 0)
512 buffer
.reset ((gdb_byte
*) xmalloc (length
));
514 read_memory (addr
, buffer
.get (), length
);
516 catch (const gdb_exception
&except
)
518 GDB_PY_HANDLE_EXCEPTION (except
);
521 gdbpy_ref
<membuf_object
> membuf_obj (PyObject_New (membuf_object
,
522 &membuf_object_type
));
523 if (membuf_obj
== NULL
)
526 membuf_obj
->buffer
= buffer
.release ();
527 membuf_obj
->addr
= addr
;
528 membuf_obj
->length
= length
;
531 result
= PyMemoryView_FromObject ((PyObject
*) membuf_obj
.get ());
533 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
.get (), 0,
540 /* Implementation of Inferior.write_memory (address, buffer [, length]).
541 Writes the contents of BUFFER (a Python object supporting the read
542 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
543 bytes from BUFFER, or its entire contents if the argument is not
544 provided. The function returns nothing. Returns NULL on error, with
545 a python exception set. */
547 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
549 struct gdb_exception except
;
551 const gdb_byte
*buffer
;
552 CORE_ADDR addr
, length
;
553 PyObject
*addr_obj
, *length_obj
= NULL
;
554 static const char *keywords
[] = { "address", "buffer", "length", NULL
};
557 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "Os*|O", keywords
,
558 &addr_obj
, &pybuf
, &length_obj
))
561 Py_buffer_up
buffer_up (&pybuf
);
562 buffer
= (const gdb_byte
*) pybuf
.buf
;
565 if (get_addr_from_python (addr_obj
, &addr
) < 0)
570 else if (get_addr_from_python (length_obj
, &length
) < 0)
575 write_memory_with_notification (addr
, buffer
, length
);
577 catch (gdb_exception
&ex
)
579 except
= std::move (ex
);
582 GDB_PY_HANDLE_EXCEPTION (except
);
587 /* Destructor of Membuf objects. */
589 mbpy_dealloc (PyObject
*self
)
591 xfree (((membuf_object
*) self
)->buffer
);
592 Py_TYPE (self
)->tp_free (self
);
595 /* Return a description of the Membuf object. */
597 mbpy_str (PyObject
*self
)
599 membuf_object
*membuf_obj
= (membuf_object
*) self
;
601 return PyString_FromFormat (_("Memory buffer for address %s, \
602 which is %s bytes long."),
603 paddress (python_gdbarch
, membuf_obj
->addr
),
604 pulongest (membuf_obj
->length
));
610 get_buffer (PyObject
*self
, Py_buffer
*buf
, int flags
)
612 membuf_object
*membuf_obj
= (membuf_object
*) self
;
615 ret
= PyBuffer_FillInfo (buf
, self
, membuf_obj
->buffer
,
616 membuf_obj
->length
, 0,
619 /* Despite the documentation saying this field is a "const char *",
620 in Python 3.4 at least, it's really a "char *". */
621 buf
->format
= (char *) "c";
629 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
631 membuf_object
*membuf_obj
= (membuf_object
*) self
;
635 PyErr_SetString (PyExc_SystemError
,
636 _("The memory buffer supports only one segment."));
640 *ptrptr
= membuf_obj
->buffer
;
642 return membuf_obj
->length
;
646 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
648 return get_read_buffer (self
, segment
, ptrptr
);
652 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
655 *lenp
= ((membuf_object
*) self
)->length
;
661 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
666 ret
= get_read_buffer (self
, segment
, &ptr
);
667 *ptrptr
= (char *) ptr
;
675 gdb.search_memory (address, length, pattern). ADDRESS is the
676 address to start the search. LENGTH specifies the scope of the
677 search from ADDRESS. PATTERN is the pattern to search for (and
678 must be a Python object supporting the buffer protocol).
679 Returns a Python Long object holding the address where the pattern
680 was located, or if the pattern was not found, returns None. Returns NULL
681 on error, with a python exception set. */
683 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
685 struct gdb_exception except
;
686 CORE_ADDR start_addr
, length
;
687 static const char *keywords
[] = { "address", "length", "pattern", NULL
};
688 PyObject
*start_addr_obj
, *length_obj
;
689 Py_ssize_t pattern_size
;
690 const gdb_byte
*buffer
;
691 CORE_ADDR found_addr
;
695 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OOs*", keywords
,
696 &start_addr_obj
, &length_obj
,
700 Py_buffer_up
buffer_up (&pybuf
);
701 buffer
= (const gdb_byte
*) pybuf
.buf
;
702 pattern_size
= pybuf
.len
;
704 if (get_addr_from_python (start_addr_obj
, &start_addr
) < 0)
707 if (get_addr_from_python (length_obj
, &length
) < 0)
712 PyErr_SetString (PyExc_ValueError
,
713 _("Search range is empty."));
716 /* Watch for overflows. */
717 else if (length
> CORE_ADDR_MAX
718 || (start_addr
+ length
- 1) < start_addr
)
720 PyErr_SetString (PyExc_ValueError
,
721 _("The search range is too large."));
727 found
= target_search_memory (start_addr
, length
,
728 buffer
, pattern_size
,
731 catch (gdb_exception
&ex
)
733 except
= std::move (ex
);
736 GDB_PY_HANDLE_EXCEPTION (except
);
739 return PyLong_FromLong (found_addr
);
744 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
745 Returns True if this inferior object still exists in GDB. */
748 infpy_is_valid (PyObject
*self
, PyObject
*args
)
750 inferior_object
*inf
= (inferior_object
*) self
;
758 /* Implementation of gdb.Inferior.thread_from_handle (self, handle)
759 -> gdb.InferiorThread. */
762 infpy_thread_from_thread_handle (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
764 PyObject
*handle_obj
;
765 inferior_object
*inf_obj
= (inferior_object
*) self
;
766 static const char *keywords
[] = { "handle", NULL
};
768 INFPY_REQUIRE_VALID (inf_obj
);
770 if (! gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "O", keywords
, &handle_obj
))
773 const gdb_byte
*bytes
;
775 Py_buffer_up buffer_up
;
778 if (PyObject_CheckBuffer (handle_obj
)
779 && PyObject_GetBuffer (handle_obj
, &py_buf
, PyBUF_SIMPLE
) == 0)
781 buffer_up
.reset (&py_buf
);
782 bytes
= (const gdb_byte
*) py_buf
.buf
;
783 bytes_len
= py_buf
.len
;
785 else if (gdbpy_is_value_object (handle_obj
))
787 struct value
*val
= value_object_to_value (handle_obj
);
788 bytes
= value_contents_all (val
);
789 bytes_len
= TYPE_LENGTH (value_type (val
));
793 PyErr_SetString (PyExc_TypeError
,
794 _("Argument 'handle' must be a thread handle object."));
801 struct thread_info
*thread_info
;
803 thread_info
= find_thread_by_handle
804 (gdb::array_view
<const gdb_byte
> (bytes
, bytes_len
),
806 if (thread_info
!= NULL
)
807 return thread_to_thread_object (thread_info
).release ();
809 catch (const gdb_exception
&except
)
811 GDB_PY_HANDLE_EXCEPTION (except
);
817 /* Implementation of gdb.Inferior.architecture. */
820 infpy_architecture (PyObject
*self
, PyObject
*args
)
822 inferior_object
*inf
= (inferior_object
*) self
;
824 INFPY_REQUIRE_VALID (inf
);
826 return gdbarch_to_arch_object (inf
->inferior
->gdbarch
);
829 /* Implement repr() for gdb.Inferior. */
832 infpy_repr (PyObject
*obj
)
834 inferior_object
*self
= (inferior_object
*) obj
;
835 inferior
*inf
= self
->inferior
;
838 return PyString_FromString ("<gdb.Inferior (invalid)>");
840 return PyString_FromFormat ("<gdb.Inferior num=%d, pid=%d>",
846 infpy_dealloc (PyObject
*obj
)
848 inferior_object
*inf_obj
= (inferior_object
*) obj
;
849 struct inferior
*inf
= inf_obj
->inferior
;
854 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
855 Py_TYPE (obj
)->tp_free (obj
);
858 /* Clear the INFERIOR pointer in an Inferior object and clear the
861 py_free_inferior (struct inferior
*inf
, void *datum
)
863 struct threadlist_entry
*th_entry
, *th_tmp
;
865 if (!gdb_python_initialized
)
868 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
869 gdbpy_ref
<inferior_object
> inf_obj ((inferior_object
*) datum
);
871 inf_obj
->inferior
= NULL
;
873 /* Deallocate threads list. */
874 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
877 th_entry
= th_entry
->next
;
881 inf_obj
->nthreads
= 0;
884 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
885 Returns the current inferior object. */
888 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
891 inferior_to_inferior_object (current_inferior ()).release ());
895 gdbpy_initialize_inferior (void)
897 if (PyType_Ready (&inferior_object_type
) < 0)
900 if (gdb_pymodule_addobject (gdb_module
, "Inferior",
901 (PyObject
*) &inferior_object_type
) < 0)
905 register_inferior_data_with_cleanup (NULL
, py_free_inferior
);
907 gdb::observers::new_thread
.attach (add_thread_object
);
908 gdb::observers::thread_exit
.attach (delete_thread_object
);
909 gdb::observers::normal_stop
.attach (python_on_normal_stop
);
910 gdb::observers::target_resumed
.attach (python_on_resume
);
911 gdb::observers::inferior_call_pre
.attach (python_on_inferior_call_pre
);
912 gdb::observers::inferior_call_post
.attach (python_on_inferior_call_post
);
913 gdb::observers::memory_changed
.attach (python_on_memory_change
);
914 gdb::observers::register_changed
.attach (python_on_register_change
);
915 gdb::observers::inferior_exit
.attach (python_inferior_exit
);
916 gdb::observers::new_objfile
.attach (python_new_objfile
);
917 gdb::observers::inferior_added
.attach (python_new_inferior
);
918 gdb::observers::inferior_removed
.attach (python_inferior_deleted
);
920 membuf_object_type
.tp_new
= PyType_GenericNew
;
921 if (PyType_Ready (&membuf_object_type
) < 0)
924 return gdb_pymodule_addobject (gdb_module
, "Membuf",
925 (PyObject
*) &membuf_object_type
);
928 static gdb_PyGetSetDef inferior_object_getset
[] =
930 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
931 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
933 { "was_attached", infpy_get_was_attached
, NULL
,
934 "True if the inferior was created using 'attach'.", NULL
},
935 { "progspace", infpy_get_progspace
, NULL
, "Program space of this inferior" },
939 static PyMethodDef inferior_object_methods
[] =
941 { "is_valid", infpy_is_valid
, METH_NOARGS
,
942 "is_valid () -> Boolean.\n\
943 Return true if this inferior is valid, false if not." },
944 { "threads", infpy_threads
, METH_NOARGS
,
945 "Return all the threads of this inferior." },
946 { "read_memory", (PyCFunction
) infpy_read_memory
,
947 METH_VARARGS
| METH_KEYWORDS
,
948 "read_memory (address, length) -> buffer\n\
949 Return a buffer object for reading from the inferior's memory." },
950 { "write_memory", (PyCFunction
) infpy_write_memory
,
951 METH_VARARGS
| METH_KEYWORDS
,
952 "write_memory (address, buffer [, length])\n\
953 Write the given buffer object to the inferior's memory." },
954 { "search_memory", (PyCFunction
) infpy_search_memory
,
955 METH_VARARGS
| METH_KEYWORDS
,
956 "search_memory (address, length, pattern) -> long\n\
957 Return a long with the address of a match, or None." },
958 /* thread_from_thread_handle is deprecated. */
959 { "thread_from_thread_handle", (PyCFunction
) infpy_thread_from_thread_handle
,
960 METH_VARARGS
| METH_KEYWORDS
,
961 "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
962 Return thread object corresponding to thread handle.\n\
963 This method is deprecated - use thread_from_handle instead." },
964 { "thread_from_handle", (PyCFunction
) infpy_thread_from_thread_handle
,
965 METH_VARARGS
| METH_KEYWORDS
,
966 "thread_from_handle (handle) -> gdb.InferiorThread.\n\
967 Return thread object corresponding to thread handle." },
968 { "architecture", (PyCFunction
) infpy_architecture
, METH_NOARGS
,
969 "architecture () -> gdb.Architecture\n\
970 Return architecture of this inferior." },
974 PyTypeObject inferior_object_type
=
976 PyVarObject_HEAD_INIT (NULL
, 0)
977 "gdb.Inferior", /* tp_name */
978 sizeof (inferior_object
), /* tp_basicsize */
980 infpy_dealloc
, /* tp_dealloc */
985 infpy_repr
, /* tp_repr */
986 0, /* tp_as_number */
987 0, /* tp_as_sequence */
988 0, /* tp_as_mapping */
994 0, /* tp_as_buffer */
995 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
996 "GDB inferior object", /* tp_doc */
999 0, /* tp_richcompare */
1000 0, /* tp_weaklistoffset */
1002 0, /* tp_iternext */
1003 inferior_object_methods
, /* tp_methods */
1005 inferior_object_getset
, /* tp_getset */
1008 0, /* tp_descr_get */
1009 0, /* tp_descr_set */
1010 0, /* tp_dictoffset */
1017 static PyBufferProcs buffer_procs
=
1024 static PyBufferProcs buffer_procs
= {
1030 #endif /* IS_PY3K */
1032 PyTypeObject membuf_object_type
= {
1033 PyVarObject_HEAD_INIT (NULL
, 0)
1034 "gdb.Membuf", /*tp_name*/
1035 sizeof (membuf_object
), /*tp_basicsize*/
1037 mbpy_dealloc
, /*tp_dealloc*/
1044 0, /*tp_as_sequence*/
1045 0, /*tp_as_mapping*/
1048 mbpy_str
, /*tp_str*/
1051 &buffer_procs
, /*tp_as_buffer*/
1052 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1053 "GDB memory buffer object", /*tp_doc*/
1054 0, /* tp_traverse */
1056 0, /* tp_richcompare */
1057 0, /* tp_weaklistoffset */
1059 0, /* tp_iternext */
1065 0, /* tp_descr_get */
1066 0, /* tp_descr_set */
1067 0, /* tp_dictoffset */