diff options
Diffstat (limited to 'gdb/python')
| -rw-r--r-- | gdb/python/py-event.h | 16 | ||||
| -rw-r--r-- | gdb/python/py-events.h | 3 | ||||
| -rw-r--r-- | gdb/python/py-evts.c | 12 | ||||
| -rw-r--r-- | gdb/python/py-inferior.c | 70 | ||||
| -rw-r--r-- | gdb/python/py-infevents.c | 263 | ||||
| -rw-r--r-- | gdb/python/py-infthread.c | 39 | ||||
| -rw-r--r-- | gdb/python/python-internal.h | 9 | ||||
| -rw-r--r-- | gdb/python/python.c | 4 |
8 files changed, 402 insertions, 14 deletions
diff --git a/gdb/python/py-event.h b/gdb/python/py-event.h index c0bd9a6..6df92ea 100644 --- a/gdb/python/py-event.h +++ b/gdb/python/py-event.h @@ -105,6 +105,22 @@ typedef struct extern int emit_continue_event (ptid_t ptid); extern int emit_exited_event (const LONGEST *exit_code, struct inferior *inf); +/* For inferior function call events, discriminate whether event is + before or after the call. */ + +typedef enum +{ + /* Before the call */ + INFERIOR_CALL_PRE, + /* after the call */ + INFERIOR_CALL_POST, +} inferior_call_kind; + +extern int emit_inferior_call_event (inferior_call_kind kind, + ptid_t thread, CORE_ADDR addr); +extern int emit_register_changed_event (struct frame_info *frame, + int regnum); +extern int emit_memory_changed_event (CORE_ADDR addr, ssize_t len); extern int evpy_emit_event (PyObject *event, eventregistry_object *registry) CPYCHECKER_STEALS_REFERENCE_TO_ARG (1); diff --git a/gdb/python/py-events.h b/gdb/python/py-events.h index 0b5656b..4d5b895 100644 --- a/gdb/python/py-events.h +++ b/gdb/python/py-events.h @@ -47,6 +47,9 @@ typedef struct eventregistry_object *exited; eventregistry_object *new_objfile; eventregistry_object *clear_objfiles; + eventregistry_object *inferior_call; + eventregistry_object *memory_changed; + eventregistry_object *register_changed; PyObject *module; diff --git a/gdb/python/py-evts.c b/gdb/python/py-evts.c index d08b14b..e006763 100644 --- a/gdb/python/py-evts.c +++ b/gdb/python/py-evts.c @@ -73,6 +73,18 @@ gdbpy_initialize_py_events (void) if (add_new_registry (&gdb_py_events.exited, "exited") < 0) return -1; + if (add_new_registry (&gdb_py_events.inferior_call, + "inferior_call") < 0) + return -1; + + if (add_new_registry (&gdb_py_events.memory_changed, + "memory_changed") < 0) + return -1; + + if (add_new_registry (&gdb_py_events.register_changed, + "register_changed") < 0) + return -1; + if (add_new_registry (&gdb_py_events.new_objfile, "new_objfile") < 0) return -1; diff --git a/gdb/python/py-inferior.c b/gdb/python/py-inferior.c index 1b38d55..9af8173 100644 --- a/gdb/python/py-inferior.c +++ b/gdb/python/py-inferior.c @@ -116,6 +116,72 @@ python_on_resume (ptid_t ptid) do_cleanups (cleanup); } +/* Callback, registered as an observer, that notifies Python listeners + when an inferior function call is about to be made. */ + +static void +python_on_inferior_call_pre (ptid_t thread, CORE_ADDR address) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (target_gdbarch (), current_language); + + if (emit_inferior_call_event (INFERIOR_CALL_PRE, thread, address) < 0) + gdbpy_print_stack (); + + do_cleanups (cleanup); +} + +/* Callback, registered as an observer, that notifies Python listeners + when an inferior function call has completed. */ + +static void +python_on_inferior_call_post (ptid_t thread, CORE_ADDR address) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (target_gdbarch (), current_language); + + if (emit_inferior_call_event (INFERIOR_CALL_POST, thread, address) < 0) + gdbpy_print_stack (); + + do_cleanups (cleanup); +} + +/* Callback, registered as an observer, that notifies Python listeners + when a part of memory has been modified by user action (eg via a + 'set' command). */ + +static void +python_on_memory_change (struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (target_gdbarch (), current_language); + + if (emit_memory_changed_event (addr, len) < 0) + gdbpy_print_stack (); + + do_cleanups (cleanup); +} + +/* Callback, registered as an observer, that notifies Python listeners + when a register has been modified by user action (eg via a 'set' + command). */ + +static void +python_on_register_change (struct frame_info *frame, int regnum) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (target_gdbarch (), current_language); + + if (emit_register_changed_event (frame, regnum) < 0) + gdbpy_print_stack (); + + do_cleanups (cleanup); +} + static void python_inferior_exit (struct inferior *inf) { @@ -802,6 +868,10 @@ gdbpy_initialize_inferior (void) observer_attach_thread_exit (delete_thread_object); observer_attach_normal_stop (python_on_normal_stop); observer_attach_target_resumed (python_on_resume); + observer_attach_inferior_call_pre (python_on_inferior_call_pre); + observer_attach_inferior_call_post (python_on_inferior_call_post); + observer_attach_memory_changed (python_on_memory_change); + observer_attach_register_changed (python_on_register_change); observer_attach_inferior_exit (python_inferior_exit); observer_attach_new_objfile (python_new_objfile); diff --git a/gdb/python/py-infevents.c b/gdb/python/py-infevents.c new file mode 100644 index 0000000..beb0598 --- /dev/null +++ b/gdb/python/py-infevents.c @@ -0,0 +1,263 @@ +/* Python interface to inferior function events. + + Copyright (C) 2013, 2014 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "defs.h" +#include "py-event.h" + +static PyTypeObject inferior_call_pre_event_object_type + CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object"); +static PyTypeObject inferior_call_post_event_object_type + CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object"); +static PyTypeObject register_changed_event_object_type + CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object"); +static PyTypeObject memory_changed_event_object_type + CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("event_object"); + +/* Construct either a gdb.InferiorCallPreEvent or a + gdb.InferiorCallPostEvent. */ + +static PyObject * +create_inferior_call_event_object (inferior_call_kind flag, ptid_t ptid, + CORE_ADDR addr) +{ + int pid; + long tid, lwp; + PyObject *event; + PyObject *ptid_obj = NULL; + PyObject *addr_obj = NULL; + int failed; + struct cleanup *cleanups; + struct cleanup *member_cleanups; + + switch (flag) + { + case INFERIOR_CALL_PRE: + event = create_event_object (&inferior_call_pre_event_object_type); + break; + case INFERIOR_CALL_POST: + event = create_event_object (&inferior_call_post_event_object_type); + break; + default: + return NULL; + } + + cleanups = make_cleanup_py_decref (event); + + ptid_obj = gdbpy_create_ptid_object (ptid); + if (ptid_obj == NULL) + goto fail; + member_cleanups = make_cleanup_py_decref (ptid_obj); + + failed = evpy_add_attribute (event, "ptid", ptid_obj) < 0; + if (failed) + goto fail; + + addr_obj = PyLong_FromLongLong (addr); + if (addr_obj == NULL) + goto fail; + make_cleanup_py_decref (addr_obj); + + failed = evpy_add_attribute (event, "address", addr_obj) < 0; + if (failed) + goto fail; + + do_cleanups (member_cleanups); + discard_cleanups (cleanups); + return event; + + fail: + do_cleanups (cleanups); + return NULL; +} + +/* Construct a gdb.RegisterChangedEvent containing the affected + register number. */ + +static PyObject * +create_register_changed_event_object (struct frame_info *frame, + int regnum) +{ + PyObject *event; + PyObject *frame_obj = NULL; + PyObject *regnum_obj = NULL; + int failed; + struct cleanup *cleanups; + struct cleanup *member_cleanups; + + event = create_event_object (®ister_changed_event_object_type); + if (event == NULL) + return NULL; + + cleanups = make_cleanup_py_decref (event); + + frame_obj = frame_info_to_frame_object (frame); + if (frame_obj == NULL) + goto fail; + member_cleanups = make_cleanup_py_decref (frame_obj); + + failed = evpy_add_attribute (event, "frame", frame_obj) < 0; + if (failed) + goto fail; + + regnum_obj = PyLong_FromLongLong (regnum); + if (regnum_obj == NULL) + goto fail; + make_cleanup_py_decref (regnum_obj); + + failed = evpy_add_attribute (event, "regnum", regnum_obj) < 0; + if (failed) + goto fail; + + do_cleanups (member_cleanups); + discard_cleanups (cleanups); + return event; + + fail: + do_cleanups (cleanups); + return NULL; +} + +/* Construct a gdb.MemoryChangedEvent describing the extent of the + affected memory. */ + +static PyObject * +create_memory_changed_event_object (CORE_ADDR addr, ssize_t len) +{ + PyObject *event; + PyObject *addr_obj = NULL; + PyObject *len_obj = NULL; + int failed; + struct cleanup *cleanups; + struct cleanup *member_cleanups; + + event = create_event_object (&memory_changed_event_object_type); + + if (event == NULL) + return NULL; + cleanups = make_cleanup_py_decref (event); + + addr_obj = PyLong_FromLongLong (addr); + if (addr_obj == NULL) + goto fail; + member_cleanups = make_cleanup_py_decref (addr_obj); + + failed = evpy_add_attribute (event, "address", addr_obj) < 0; + if (failed) + goto fail; + + len_obj = PyLong_FromLong (len); + if (len_obj == NULL) + goto fail; + make_cleanup_py_decref (len_obj); + + failed = evpy_add_attribute (event, "length", len_obj) < 0; + if (failed) + goto fail; + + do_cleanups (member_cleanups); + discard_cleanups (cleanups); + return event; + + fail: + do_cleanups (cleanups); + return NULL; +} + +/* Callback function which notifies observers when an event occurs which + calls a function in the inferior. + This function will create a new Python inferior-call event object. + Return -1 if emit fails. */ + +int +emit_inferior_call_event (inferior_call_kind flag, ptid_t thread, + CORE_ADDR addr) +{ + PyObject *event; + + if (evregpy_no_listeners_p (gdb_py_events.inferior_call)) + return 0; + + event = create_inferior_call_event_object (flag, thread, addr); + if (event != NULL) + return evpy_emit_event (event, gdb_py_events.inferior_call); + return -1; +} + +/* Callback when memory is modified by the user. This function will + create a new Python memory changed event object. */ + +int +emit_memory_changed_event (CORE_ADDR addr, ssize_t len) +{ + PyObject *event; + + if (evregpy_no_listeners_p (gdb_py_events.memory_changed)) + return 0; + + event = create_memory_changed_event_object (addr, len); + if (event != NULL) + return evpy_emit_event (event, gdb_py_events.memory_changed); + return -1; +} + +/* Callback when a register is modified by the user. This function + will create a new Python register changed event object. */ + +int +emit_register_changed_event (struct frame_info* frame, int regnum) +{ + PyObject *event; + + if (evregpy_no_listeners_p (gdb_py_events.register_changed)) + return 0; + + event = create_register_changed_event_object (frame, regnum); + if (event != NULL) + return evpy_emit_event (event, gdb_py_events.register_changed); + return -1; +} + + +GDBPY_NEW_EVENT_TYPE (inferior_call_pre, + "gdb.InferiorCallPreEvent", + "InferiorCallPreEvent", + "GDB inferior function pre-call event object", + event_object_type, + static); + +GDBPY_NEW_EVENT_TYPE (inferior_call_post, + "gdb.InferiorCallPostEvent", + "InferiorCallPostEvent", + "GDB inferior function post-call event object", + event_object_type, + static); + +GDBPY_NEW_EVENT_TYPE (register_changed, + "gdb.RegisterChangedEvent", + "RegisterChangedEvent", + "GDB register change event object", + event_object_type, + static); + +GDBPY_NEW_EVENT_TYPE (memory_changed, + "gdb.MemoryChangedEvent", + "MemoryChangedEvent", + "GDB memory change event object", + event_object_type, + static); diff --git a/gdb/python/py-infthread.c b/gdb/python/py-infthread.c index 7fa2ca8..67a187c 100644 --- a/gdb/python/py-infthread.c +++ b/gdb/python/py-infthread.c @@ -134,23 +134,10 @@ thpy_get_ptid (PyObject *self, void *closure) int pid; long tid, lwp; thread_object *thread_obj = (thread_object *) self; - PyObject *ret; THPY_REQUIRE_VALID (thread_obj); - ret = PyTuple_New (3); - if (!ret) - return NULL; - - pid = ptid_get_pid (thread_obj->thread->ptid); - lwp = ptid_get_lwp (thread_obj->thread->ptid); - tid = ptid_get_tid (thread_obj->thread->ptid); - - PyTuple_SET_ITEM (ret, 0, PyInt_FromLong (pid)); - PyTuple_SET_ITEM (ret, 1, PyInt_FromLong (lwp)); - PyTuple_SET_ITEM (ret, 2, PyInt_FromLong (tid)); - - return ret; + return gdbpy_create_ptid_object (thread_obj->thread->ptid); } /* Implementation of InferiorThread.switch (). @@ -236,6 +223,30 @@ thpy_is_valid (PyObject *self, PyObject *args) Py_RETURN_TRUE; } +/* Return a reference to a new Python object representing a ptid_t. + The object is a tuple containing (pid, lwp, tid). */ +PyObject * +gdbpy_create_ptid_object (ptid_t ptid) +{ + int pid; + long tid, lwp; + PyObject *ret; + + ret = PyTuple_New (3); + if (!ret) + return NULL; + + pid = ptid_get_pid (ptid); + lwp = ptid_get_lwp (ptid); + tid = ptid_get_tid (ptid); + + PyTuple_SET_ITEM (ret, 0, PyInt_FromLong (pid)); + PyTuple_SET_ITEM (ret, 1, PyInt_FromLong (lwp)); + PyTuple_SET_ITEM (ret, 2, PyInt_FromLong (tid)); + + return ret; +} + /* Implementation of gdb.selected_thread () -> gdb.InferiorThread. Returns the selected thread object. */ diff --git a/gdb/python/python-internal.h b/gdb/python/python-internal.h index 54eebeb..716c0de 100644 --- a/gdb/python/python-internal.h +++ b/gdb/python/python-internal.h @@ -363,6 +363,7 @@ PyObject *gdbpy_create_lazy_string_object (CORE_ADDR address, long length, const char *encoding, struct type *type); PyObject *gdbpy_inferiors (PyObject *unused, PyObject *unused2); +PyObject *gdbpy_create_ptid_object (ptid_t ptid); PyObject *gdbpy_selected_thread (PyObject *self, PyObject *args); PyObject *gdbpy_selected_inferior (PyObject *self, PyObject *args); PyObject *gdbpy_string_to_argv (PyObject *self, PyObject *args); @@ -464,6 +465,14 @@ int gdbpy_initialize_breakpoint_event (void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; int gdbpy_initialize_continue_event (void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; +int gdbpy_initialize_inferior_call_pre_event (void) + CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; +int gdbpy_initialize_inferior_call_post_event (void) + CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; +int gdbpy_initialize_register_changed_event (void) + CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; +int gdbpy_initialize_memory_changed_event (void) + CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; int gdbpy_initialize_exited_event (void) CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION; int gdbpy_initialize_thread_event (void) diff --git a/gdb/python/python.c b/gdb/python/python.c index ca531e2..1362bd2 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -1753,6 +1753,10 @@ message == an error message without a stack will be printed."), || gdbpy_initialize_signal_event () < 0 || gdbpy_initialize_breakpoint_event () < 0 || gdbpy_initialize_continue_event () < 0 + || gdbpy_initialize_inferior_call_pre_event () < 0 + || gdbpy_initialize_inferior_call_post_event () < 0 + || gdbpy_initialize_register_changed_event () < 0 + || gdbpy_initialize_memory_changed_event () < 0 || gdbpy_initialize_exited_event () < 0 || gdbpy_initialize_thread_event () < 0 || gdbpy_initialize_new_objfile_event () < 0 |