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 "common/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. */
211 gdbpy_ref
<inferior_object
>
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
);
232 /* We are returning a new reference. */
233 gdb_assert (inf_obj
!= nullptr);
234 return gdbpy_ref
<inferior_object
>::new_reference (inf_obj
);
237 /* Called when a new inferior is created. Notifies any Python event
240 python_new_inferior (struct inferior
*inf
)
242 if (!gdb_python_initialized
)
245 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
247 if (evregpy_no_listeners_p (gdb_py_events
.new_inferior
))
250 gdbpy_ref
<inferior_object
> inf_obj
= inferior_to_inferior_object (inf
);
253 gdbpy_print_stack ();
257 gdbpy_ref
<> event
= create_event_object (&new_inferior_event_object_type
);
259 || evpy_add_attribute (event
.get (), "inferior",
260 (PyObject
*) 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
<inferior_object
> 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",
288 (PyObject
*) inf_obj
.get ()) < 0
289 || evpy_emit_event (event
.get (), gdb_py_events
.inferior_deleted
) < 0)
290 gdbpy_print_stack ();
294 thread_to_thread_object (thread_info
*thr
)
296 gdbpy_ref
<inferior_object
> inf_obj
= inferior_to_inferior_object (thr
->inf
);
300 for (threadlist_entry
*thread
= inf_obj
->threads
;
302 thread
= thread
->next
)
303 if (thread
->thread_obj
->thread
== thr
)
304 return gdbpy_ref
<>::new_reference ((PyObject
*) thread
->thread_obj
);
306 PyErr_SetString (PyExc_SystemError
,
307 _("could not find gdb thread object"));
312 add_thread_object (struct thread_info
*tp
)
314 thread_object
*thread_obj
;
315 inferior_object
*inf_obj
;
316 struct threadlist_entry
*entry
;
318 if (!gdb_python_initialized
)
321 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
323 thread_obj
= create_thread_object (tp
);
326 gdbpy_print_stack ();
330 inf_obj
= (inferior_object
*) thread_obj
->inf_obj
;
332 entry
= XNEW (struct threadlist_entry
);
333 entry
->thread_obj
= thread_obj
;
334 entry
->next
= inf_obj
->threads
;
336 inf_obj
->threads
= entry
;
339 if (evregpy_no_listeners_p (gdb_py_events
.new_thread
))
342 gdbpy_ref
<> event
= create_thread_event_object (&new_thread_event_object_type
,
343 (PyObject
*) thread_obj
);
345 || evpy_emit_event (event
.get (), gdb_py_events
.new_thread
) < 0)
346 gdbpy_print_stack ();
350 delete_thread_object (struct thread_info
*tp
, int ignore
)
352 struct threadlist_entry
**entry
, *tmp
;
354 if (!gdb_python_initialized
)
357 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
359 gdbpy_ref
<inferior_object
> inf_obj
= inferior_to_inferior_object (tp
->inf
);
363 /* Find thread entry in its inferior's thread_list. */
364 for (entry
= &inf_obj
->threads
; *entry
!= NULL
; entry
=
366 if ((*entry
)->thread_obj
->thread
== tp
)
373 tmp
->thread_obj
->thread
= NULL
;
375 *entry
= (*entry
)->next
;
378 Py_DECREF (tmp
->thread_obj
);
383 infpy_threads (PyObject
*self
, PyObject
*args
)
386 struct threadlist_entry
*entry
;
387 inferior_object
*inf_obj
= (inferior_object
*) self
;
390 INFPY_REQUIRE_VALID (inf_obj
);
394 update_thread_list ();
396 CATCH (except
, RETURN_MASK_ALL
)
398 GDB_PY_HANDLE_EXCEPTION (except
);
402 tuple
= PyTuple_New (inf_obj
->nthreads
);
406 for (i
= 0, entry
= inf_obj
->threads
; i
< inf_obj
->nthreads
;
407 i
++, entry
= entry
->next
)
409 Py_INCREF (entry
->thread_obj
);
410 PyTuple_SET_ITEM (tuple
, i
, (PyObject
*) entry
->thread_obj
);
417 infpy_get_num (PyObject
*self
, void *closure
)
419 inferior_object
*inf
= (inferior_object
*) self
;
421 INFPY_REQUIRE_VALID (inf
);
423 return PyLong_FromLong (inf
->inferior
->num
);
427 infpy_get_pid (PyObject
*self
, void *closure
)
429 inferior_object
*inf
= (inferior_object
*) self
;
431 INFPY_REQUIRE_VALID (inf
);
433 return PyLong_FromLong (inf
->inferior
->pid
);
437 infpy_get_was_attached (PyObject
*self
, void *closure
)
439 inferior_object
*inf
= (inferior_object
*) self
;
441 INFPY_REQUIRE_VALID (inf
);
442 if (inf
->inferior
->attach_flag
)
447 /* Getter of gdb.Inferior.progspace. */
450 infpy_get_progspace (PyObject
*self
, void *closure
)
452 inferior_object
*inf
= (inferior_object
*) self
;
454 INFPY_REQUIRE_VALID (inf
);
456 program_space
*pspace
= inf
->inferior
->pspace
;
457 gdb_assert (pspace
!= nullptr);
459 return pspace_to_pspace_object (pspace
).release ();
463 build_inferior_list (struct inferior
*inf
, void *arg
)
465 PyObject
*list
= (PyObject
*) arg
;
466 gdbpy_ref
<inferior_object
> inferior
= inferior_to_inferior_object (inf
);
468 if (inferior
== NULL
)
471 return PyList_Append (list
, (PyObject
*) inferior
.get ()) ? 1 : 0;
474 /* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
475 Returns a tuple of all inferiors. */
477 gdbpy_inferiors (PyObject
*unused
, PyObject
*unused2
)
479 gdbpy_ref
<> list (PyList_New (0));
483 if (iterate_over_inferiors (build_inferior_list
, list
.get ()))
486 return PyList_AsTuple (list
.get ());
489 /* Membuf and memory manipulation. */
491 /* Implementation of Inferior.read_memory (address, length).
492 Returns a Python buffer object with LENGTH bytes of the inferior's
493 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
494 with a python exception set. */
496 infpy_read_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
498 CORE_ADDR addr
, length
;
499 gdb::unique_xmalloc_ptr
<gdb_byte
> buffer
;
500 PyObject
*addr_obj
, *length_obj
, *result
;
501 static const char *keywords
[] = { "address", "length", NULL
};
503 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OO", keywords
,
504 &addr_obj
, &length_obj
))
507 if (get_addr_from_python (addr_obj
, &addr
) < 0
508 || get_addr_from_python (length_obj
, &length
) < 0)
513 buffer
.reset ((gdb_byte
*) xmalloc (length
));
515 read_memory (addr
, buffer
.get (), length
);
517 CATCH (except
, RETURN_MASK_ALL
)
519 GDB_PY_HANDLE_EXCEPTION (except
);
523 gdbpy_ref
<membuf_object
> membuf_obj (PyObject_New (membuf_object
,
524 &membuf_object_type
));
525 if (membuf_obj
== NULL
)
528 membuf_obj
->buffer
= buffer
.release ();
529 membuf_obj
->addr
= addr
;
530 membuf_obj
->length
= length
;
533 result
= PyMemoryView_FromObject ((PyObject
*) membuf_obj
.get ());
535 result
= PyBuffer_FromReadWriteObject ((PyObject
*) membuf_obj
.get (), 0,
542 /* Implementation of Inferior.write_memory (address, buffer [, length]).
543 Writes the contents of BUFFER (a Python object supporting the read
544 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
545 bytes from BUFFER, or its entire contents if the argument is not
546 provided. The function returns nothing. Returns NULL on error, with
547 a python exception set. */
549 infpy_write_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
551 struct gdb_exception except
= exception_none
;
553 const gdb_byte
*buffer
;
554 CORE_ADDR addr
, length
;
555 PyObject
*addr_obj
, *length_obj
= NULL
;
556 static const char *keywords
[] = { "address", "buffer", "length", NULL
};
559 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "Os*|O", keywords
,
560 &addr_obj
, &pybuf
, &length_obj
))
563 Py_buffer_up
buffer_up (&pybuf
);
564 buffer
= (const gdb_byte
*) pybuf
.buf
;
567 if (get_addr_from_python (addr_obj
, &addr
) < 0)
572 else if (get_addr_from_python (length_obj
, &length
) < 0)
577 write_memory_with_notification (addr
, buffer
, length
);
579 CATCH (ex
, RETURN_MASK_ALL
)
585 GDB_PY_HANDLE_EXCEPTION (except
);
590 /* Destructor of Membuf objects. */
592 mbpy_dealloc (PyObject
*self
)
594 xfree (((membuf_object
*) self
)->buffer
);
595 Py_TYPE (self
)->tp_free (self
);
598 /* Return a description of the Membuf object. */
600 mbpy_str (PyObject
*self
)
602 membuf_object
*membuf_obj
= (membuf_object
*) self
;
604 return PyString_FromFormat (_("Memory buffer for address %s, \
605 which is %s bytes long."),
606 paddress (python_gdbarch
, membuf_obj
->addr
),
607 pulongest (membuf_obj
->length
));
613 get_buffer (PyObject
*self
, Py_buffer
*buf
, int flags
)
615 membuf_object
*membuf_obj
= (membuf_object
*) self
;
618 ret
= PyBuffer_FillInfo (buf
, self
, membuf_obj
->buffer
,
619 membuf_obj
->length
, 0,
622 /* Despite the documentation saying this field is a "const char *",
623 in Python 3.4 at least, it's really a "char *". */
624 buf
->format
= (char *) "c";
632 get_read_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
634 membuf_object
*membuf_obj
= (membuf_object
*) self
;
638 PyErr_SetString (PyExc_SystemError
,
639 _("The memory buffer supports only one segment."));
643 *ptrptr
= membuf_obj
->buffer
;
645 return membuf_obj
->length
;
649 get_write_buffer (PyObject
*self
, Py_ssize_t segment
, void **ptrptr
)
651 return get_read_buffer (self
, segment
, ptrptr
);
655 get_seg_count (PyObject
*self
, Py_ssize_t
*lenp
)
658 *lenp
= ((membuf_object
*) self
)->length
;
664 get_char_buffer (PyObject
*self
, Py_ssize_t segment
, char **ptrptr
)
669 ret
= get_read_buffer (self
, segment
, &ptr
);
670 *ptrptr
= (char *) ptr
;
678 gdb.search_memory (address, length, pattern). ADDRESS is the
679 address to start the search. LENGTH specifies the scope of the
680 search from ADDRESS. PATTERN is the pattern to search for (and
681 must be a Python object supporting the buffer protocol).
682 Returns a Python Long object holding the address where the pattern
683 was located, or if the pattern was not found, returns None. Returns NULL
684 on error, with a python exception set. */
686 infpy_search_memory (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
688 struct gdb_exception except
= exception_none
;
689 CORE_ADDR start_addr
, length
;
690 static const char *keywords
[] = { "address", "length", "pattern", NULL
};
691 PyObject
*start_addr_obj
, *length_obj
;
692 Py_ssize_t pattern_size
;
693 const gdb_byte
*buffer
;
694 CORE_ADDR found_addr
;
698 if (!gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "OOs*", keywords
,
699 &start_addr_obj
, &length_obj
,
703 Py_buffer_up
buffer_up (&pybuf
);
704 buffer
= (const gdb_byte
*) pybuf
.buf
;
705 pattern_size
= pybuf
.len
;
707 if (get_addr_from_python (start_addr_obj
, &start_addr
) < 0)
710 if (get_addr_from_python (length_obj
, &length
) < 0)
715 PyErr_SetString (PyExc_ValueError
,
716 _("Search range is empty."));
719 /* Watch for overflows. */
720 else if (length
> CORE_ADDR_MAX
721 || (start_addr
+ length
- 1) < start_addr
)
723 PyErr_SetString (PyExc_ValueError
,
724 _("The search range is too large."));
730 found
= target_search_memory (start_addr
, length
,
731 buffer
, pattern_size
,
734 CATCH (ex
, RETURN_MASK_ALL
)
740 GDB_PY_HANDLE_EXCEPTION (except
);
743 return PyLong_FromLong (found_addr
);
748 /* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
749 Returns True if this inferior object still exists in GDB. */
752 infpy_is_valid (PyObject
*self
, PyObject
*args
)
754 inferior_object
*inf
= (inferior_object
*) self
;
762 /* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
763 -> gdb.InferiorThread. */
766 infpy_thread_from_thread_handle (PyObject
*self
, PyObject
*args
, PyObject
*kw
)
768 PyObject
*handle_obj
;
769 inferior_object
*inf_obj
= (inferior_object
*) self
;
770 static const char *keywords
[] = { "thread_handle", NULL
};
772 INFPY_REQUIRE_VALID (inf_obj
);
774 if (! gdb_PyArg_ParseTupleAndKeywords (args
, kw
, "O", keywords
, &handle_obj
))
777 if (!gdbpy_is_value_object (handle_obj
))
779 PyErr_SetString (PyExc_TypeError
,
780 _("Argument 'handle_obj' must be a thread handle object."));
787 struct thread_info
*thread_info
;
788 struct value
*val
= value_object_to_value (handle_obj
);
790 thread_info
= find_thread_by_handle (val
, inf_obj
->inferior
);
791 if (thread_info
!= NULL
)
792 return thread_to_thread_object (thread_info
).release ();
794 CATCH (except
, RETURN_MASK_ALL
)
796 GDB_PY_HANDLE_EXCEPTION (except
);
803 /* Implementation of gdb.Inferior.architecture. */
806 infpy_architecture (PyObject
*self
, PyObject
*args
)
808 inferior_object
*inf
= (inferior_object
*) self
;
810 INFPY_REQUIRE_VALID (inf
);
812 return gdbarch_to_arch_object (inf
->inferior
->gdbarch
);
815 /* Implement repr() for gdb.Inferior. */
818 infpy_repr (PyObject
*obj
)
820 inferior_object
*self
= (inferior_object
*) obj
;
821 inferior
*inf
= self
->inferior
;
824 return PyString_FromString ("<gdb.Inferior (invalid)>");
826 return PyString_FromFormat ("<gdb.Inferior num=%d, pid=%d>",
832 infpy_dealloc (PyObject
*obj
)
834 inferior_object
*inf_obj
= (inferior_object
*) obj
;
835 struct inferior
*inf
= inf_obj
->inferior
;
840 set_inferior_data (inf
, infpy_inf_data_key
, NULL
);
843 /* Clear the INFERIOR pointer in an Inferior object and clear the
846 py_free_inferior (struct inferior
*inf
, void *datum
)
848 gdbpy_ref
<inferior_object
> inf_obj ((inferior_object
*) datum
);
849 struct threadlist_entry
*th_entry
, *th_tmp
;
851 if (!gdb_python_initialized
)
854 gdbpy_enter
enter_py (python_gdbarch
, python_language
);
856 inf_obj
->inferior
= NULL
;
858 /* Deallocate threads list. */
859 for (th_entry
= inf_obj
->threads
; th_entry
!= NULL
;)
861 Py_DECREF (th_entry
->thread_obj
);
864 th_entry
= th_entry
->next
;
868 inf_obj
->nthreads
= 0;
871 /* Implementation of gdb.selected_inferior() -> gdb.Inferior.
872 Returns the current inferior object. */
875 gdbpy_selected_inferior (PyObject
*self
, PyObject
*args
)
878 inferior_to_inferior_object (current_inferior ()).release ());
882 gdbpy_initialize_inferior (void)
884 if (PyType_Ready (&inferior_object_type
) < 0)
887 if (gdb_pymodule_addobject (gdb_module
, "Inferior",
888 (PyObject
*) &inferior_object_type
) < 0)
892 register_inferior_data_with_cleanup (NULL
, py_free_inferior
);
894 gdb::observers::new_thread
.attach (add_thread_object
);
895 gdb::observers::thread_exit
.attach (delete_thread_object
);
896 gdb::observers::normal_stop
.attach (python_on_normal_stop
);
897 gdb::observers::target_resumed
.attach (python_on_resume
);
898 gdb::observers::inferior_call_pre
.attach (python_on_inferior_call_pre
);
899 gdb::observers::inferior_call_post
.attach (python_on_inferior_call_post
);
900 gdb::observers::memory_changed
.attach (python_on_memory_change
);
901 gdb::observers::register_changed
.attach (python_on_register_change
);
902 gdb::observers::inferior_exit
.attach (python_inferior_exit
);
903 gdb::observers::new_objfile
.attach (python_new_objfile
);
904 gdb::observers::inferior_added
.attach (python_new_inferior
);
905 gdb::observers::inferior_removed
.attach (python_inferior_deleted
);
907 membuf_object_type
.tp_new
= PyType_GenericNew
;
908 if (PyType_Ready (&membuf_object_type
) < 0)
911 return gdb_pymodule_addobject (gdb_module
, "Membuf",
912 (PyObject
*) &membuf_object_type
);
915 static gdb_PyGetSetDef inferior_object_getset
[] =
917 { "num", infpy_get_num
, NULL
, "ID of inferior, as assigned by GDB.", NULL
},
918 { "pid", infpy_get_pid
, NULL
, "PID of inferior, as assigned by the OS.",
920 { "was_attached", infpy_get_was_attached
, NULL
,
921 "True if the inferior was created using 'attach'.", NULL
},
922 { "progspace", infpy_get_progspace
, NULL
, "Program space of this inferior" },
926 static PyMethodDef inferior_object_methods
[] =
928 { "is_valid", infpy_is_valid
, METH_NOARGS
,
929 "is_valid () -> Boolean.\n\
930 Return true if this inferior is valid, false if not." },
931 { "threads", infpy_threads
, METH_NOARGS
,
932 "Return all the threads of this inferior." },
933 { "read_memory", (PyCFunction
) infpy_read_memory
,
934 METH_VARARGS
| METH_KEYWORDS
,
935 "read_memory (address, length) -> buffer\n\
936 Return a buffer object for reading from the inferior's memory." },
937 { "write_memory", (PyCFunction
) infpy_write_memory
,
938 METH_VARARGS
| METH_KEYWORDS
,
939 "write_memory (address, buffer [, length])\n\
940 Write the given buffer object to the inferior's memory." },
941 { "search_memory", (PyCFunction
) infpy_search_memory
,
942 METH_VARARGS
| METH_KEYWORDS
,
943 "search_memory (address, length, pattern) -> long\n\
944 Return a long with the address of a match, or None." },
945 { "thread_from_thread_handle", (PyCFunction
) infpy_thread_from_thread_handle
,
946 METH_VARARGS
| METH_KEYWORDS
,
947 "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
948 Return thread object corresponding to thread handle." },
949 { "architecture", (PyCFunction
) infpy_architecture
, METH_NOARGS
,
950 "architecture () -> gdb.Architecture\n\
951 Return architecture of this inferior." },
955 PyTypeObject inferior_object_type
=
957 PyVarObject_HEAD_INIT (NULL
, 0)
958 "gdb.Inferior", /* tp_name */
959 sizeof (inferior_object
), /* tp_basicsize */
961 infpy_dealloc
, /* tp_dealloc */
966 infpy_repr
, /* tp_repr */
967 0, /* tp_as_number */
968 0, /* tp_as_sequence */
969 0, /* tp_as_mapping */
975 0, /* tp_as_buffer */
976 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_ITER
, /* tp_flags */
977 "GDB inferior object", /* tp_doc */
980 0, /* tp_richcompare */
981 0, /* tp_weaklistoffset */
984 inferior_object_methods
, /* tp_methods */
986 inferior_object_getset
, /* tp_getset */
989 0, /* tp_descr_get */
990 0, /* tp_descr_set */
991 0, /* tp_dictoffset */
998 static PyBufferProcs buffer_procs
=
1005 /* Python doesn't provide a decent way to get compatibility here. */
1006 #if HAVE_LIBPYTHON2_4
1007 #define CHARBUFFERPROC_NAME getcharbufferproc
1009 #define CHARBUFFERPROC_NAME charbufferproc
1012 static PyBufferProcs buffer_procs
= {
1016 /* The cast here works around a difference between Python 2.4 and
1018 (CHARBUFFERPROC_NAME
) get_char_buffer
1020 #endif /* IS_PY3K */
1022 PyTypeObject membuf_object_type
= {
1023 PyVarObject_HEAD_INIT (NULL
, 0)
1024 "gdb.Membuf", /*tp_name*/
1025 sizeof (membuf_object
), /*tp_basicsize*/
1027 mbpy_dealloc
, /*tp_dealloc*/
1034 0, /*tp_as_sequence*/
1035 0, /*tp_as_mapping*/
1038 mbpy_str
, /*tp_str*/
1041 &buffer_procs
, /*tp_as_buffer*/
1042 Py_TPFLAGS_DEFAULT
, /*tp_flags*/
1043 "GDB memory buffer object", /*tp_doc*/
1044 0, /* tp_traverse */
1046 0, /* tp_richcompare */
1047 0, /* tp_weaklistoffset */
1049 0, /* tp_iternext */
1055 0, /* tp_descr_get */
1056 0, /* tp_descr_set */
1057 0, /* tp_dictoffset */