New python events: infcall, register/memory changed.
authorDoug Evans <dje@google.com>
Tue, 2 Dec 2014 18:59:08 +0000 (10:59 -0800)
committerDoug Evans <dje@google.com>
Tue, 2 Dec 2014 18:59:08 +0000 (10:59 -0800)
gdb/ChangeLog:

* NEWS: Mention new Python events.
* Makefile.in (SUBDIR_PYTHON_OBS): Add py-infevents.o.
(SUBDIR_PYTHON_SRCS): Add py-infevents.c.
(py-infevents.o): New rule.
* doc/observer.texi (inferior_call_pre, inferior_call_post)
(memory_changed, register_changed): New observers.
* infcall.c (call_function_by_hand): Notify observer before and
after inferior call.
* python/py-event.h (inferior_call_kind): New enum.
(emit_inferior_call_event): New prototype.
(emit_register_changed_event): New prototype.
(emit_memory_changed_event): New prototype.
* python/py-events.h (events_object): New registries
inferior_call, memory_changed and register_changed.
* python/py-evts.c (gdbpy_initialize_py_events): Add the
inferior_call, memory_changed and register_changed registries.
* python/py-infevents.c: New.
* python/py-inferior.c (python_on_inferior_call_pre)
(python_on_inferior_call_post, python_on_register_change)
(python_on_memory_change): New functions.
(gdbpy_initialize_inferior): Attach python handler to new
observers.
* python/py-infthread.c(gdbpy_create_ptid_object): New.
(thpy_get_ptid) Use gdbpy_create_ptid_object.
* python/python-internal.h:
(gdbpy_create_ptid_object)
(gdbpy_initialize_inferior_call_pre_event)
(gdbpy_initialize_inferior_call_post_event)
(gdbpy_initialize_register_changed_event)
(gdbpy_initialize_memory_changed_event): New prototypes.
* python/python.c (_initialize_python): Initialize new events.
* valops.c (value_assign): Notify register_changed observer.

gdb/doc/ChangeLog:

* python.texi (Events In Python): Document new events
InferiorCallPreEvent, InferiorCallPostEvent, MemoryChangedEvent
and RegisterChangedEvent.

gdb/testsuite/ChangeLog:

* gdb.python/py-events.py (inferior_call_handler): New.
(register_changed_handler, memory_changed_handler): New.
(test_events.invoke): Register new handlers.
* gdb.python/py-events.exp: Add tests for inferior call,
memory_changed and register_changed events.

19 files changed:
gdb/ChangeLog
gdb/Makefile.in
gdb/NEWS
gdb/doc/ChangeLog
gdb/doc/observer.texi
gdb/doc/python.texi
gdb/infcall.c
gdb/python/py-event.h
gdb/python/py-events.h
gdb/python/py-evts.c
gdb/python/py-inferior.c
gdb/python/py-infevents.c [new file with mode: 0644]
gdb/python/py-infthread.c
gdb/python/python-internal.h
gdb/python/python.c
gdb/testsuite/ChangeLog
gdb/testsuite/gdb.python/py-events.exp
gdb/testsuite/gdb.python/py-events.py
gdb/valops.c

index d9bb4e9..acb0786 100644 (file)
@@ -1,3 +1,38 @@
+2014-12-02  Nick Bull  <nicholaspbull@gmail.com>
+
+       * NEWS: Mention new Python events.
+       * Makefile.in (SUBDIR_PYTHON_OBS): Add py-infevents.o.
+       (SUBDIR_PYTHON_SRCS): Add py-infevents.c.
+       (py-infevents.o): New rule.
+       * doc/observer.texi (inferior_call_pre, inferior_call_post)
+       (memory_changed, register_changed): New observers.
+       * infcall.c (call_function_by_hand): Notify observer before and
+       after inferior call.
+       * python/py-event.h (inferior_call_kind): New enum.
+       (emit_inferior_call_event): New prototype.
+       (emit_register_changed_event): New prototype.
+       (emit_memory_changed_event): New prototype.
+       * python/py-events.h (events_object): New registries
+       inferior_call, memory_changed and register_changed.
+       * python/py-evts.c (gdbpy_initialize_py_events): Add the
+       inferior_call, memory_changed and register_changed registries.
+       * python/py-infevents.c: New.
+       * python/py-inferior.c (python_on_inferior_call_pre)
+       (python_on_inferior_call_post, python_on_register_change)
+       (python_on_memory_change): New functions.
+       (gdbpy_initialize_inferior): Attach python handler to new
+       observers.
+       * python/py-infthread.c(gdbpy_create_ptid_object): New.
+       (thpy_get_ptid) Use gdbpy_create_ptid_object.
+       * python/python-internal.h:
+       (gdbpy_create_ptid_object)
+       (gdbpy_initialize_inferior_call_pre_event)
+       (gdbpy_initialize_inferior_call_post_event)
+       (gdbpy_initialize_register_changed_event)
+       (gdbpy_initialize_memory_changed_event): New prototypes.
+       * python/python.c (_initialize_python): Initialize new events.
+       * valops.c (value_assign): Notify register_changed observer.
+
 2014-12-02  Doug Evans  <dje@google.com>
 
        * python/py-infthread.c: Whitespace fixes.
index 1da8af6..81c8c94 100644 (file)
@@ -361,6 +361,7 @@ SUBDIR_PYTHON_OBS = \
        py-function.o \
        py-gdb-readline.o \
        py-inferior.o \
+       py-infevents.o \
        py-infthread.o \
        py-lazy-string.o \
        py-linetable.o \
@@ -399,6 +400,7 @@ SUBDIR_PYTHON_SRCS = \
        python/py-function.c \
        python/py-gdb-readline.c \
        python/py-inferior.c \
+       python/py-infevents.c \
        python/py-infthread.c \
        python/py-lazy-string.c \
        python/py-linetable.c \
@@ -2478,6 +2480,10 @@ py-inferior.o: $(srcdir)/python/py-inferior.c
        $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-inferior.c
        $(POSTCOMPILE)
 
+py-infevents.o: $(srcdir)/python/py-infevents.c
+       $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-infevents.c
+       $(POSTCOMPILE)
+
 py-infthread.o: $(srcdir)/python/py-infthread.c
        $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-infthread.c
        $(POSTCOMPILE)
index d38266f..7262502 100644 (file)
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -1,6 +1,16 @@
                What has changed in GDB?
             (Organized release by release)
 
+* Python Scripting
+
+  New events which are triggered when GDB modifies the state of the 
+  inferior.
+
+  ** gdb.events.inferior_call_pre: Function call is about to be made.
+  ** gdb.events.inferior_call_post: Function call has just been made.
+  ** gdb.events.memory_changed: A memory location has been altered.
+  ** gdb.events.register_changed: A register has been altered.
+
 *** Changes since GDB 7.8
 
 * GDB now supports hardware watchpoints on x86 GNU Hurd.
index 3b27128..08b49f5 100644 (file)
@@ -1,3 +1,9 @@
+2014-12-02  Nick Bull  <nicholaspbull@gmail.com>
+
+       * python.texi (Events In Python): Document new events
+       InferiorCallPreEvent, InferiorCallPostEvent, MemoryChangedEvent
+       and RegisterChangedEvent.
+
 2014-11-30  Jan Kratochvil  <jan.kratochvil@redhat.com>
 
        Add add-auto-load-scripts-directory.
index 2757587..7c4af6b 100644 (file)
@@ -281,6 +281,22 @@ The trace state variable @var{tsv} is deleted.  If @var{tsv} is
 The trace state value @var{tsv} is modified.
 @end deftypefun
 
+@deftypefun void inferior_call_pre (ptid_t @var{thread}, CORE_ADDR @var{address})
+An inferior function at @var{address} is about to be called in thread
+@var{thread}.
+@end deftypefun
+
+@deftypefun void inferior_call_post (ptid_t @var{thread}, CORE_ADDR @var{address})
+The inferior function at @var{address} has just been called.  This observer
+is called even if the inferior exits during the call.  @var{thread} is the
+thread in which the function was called, which may be different from the
+current thread.
+@end deftypefun
+
+@deftypefun void register_changed (struct frame_info *@var{frame}, int @var{regnum})
+A register in the inferior has been modified by the @value{GDBN} user.
+@end deftypefun
+
 @deftypefun void test_notification (int @var{somearg})
 This observer is used for internal testing.  Do not use.  
 See testsuite/gdb.gdb/observer.exp.
index 5b35306..63db2b2 100644 (file)
@@ -2738,6 +2738,55 @@ A reference to the program space (@code{gdb.Progspace}) whose objfile list has
 been cleared.  @xref{Progspaces In Python}.
 @end defvar
 
+@item events.inferior_call_pre
+Emits @code{gdb.InferiorCallPreEvent} which indicates that a function in
+the inferior is about to be called.
+
+@defvar InferiorCallPreEvent.ptid
+The thread in which the call will be run.
+@end defvar
+
+@defvar InferiorCallPreEvent.address
+The location of the function to be called.
+@end defvar
+
+@item events.inferior_call_post
+Emits @code{gdb.InferiorCallPostEvent} which indicates that a function in
+the inferior has returned.
+
+@defvar InferiorCallPostEvent.ptid
+The thread in which the call was run.
+@end defvar
+
+@defvar InferiorCallPostEvent.address
+The location of the function that was called.
+@end defvar
+
+@item events.memory_changed
+Emits @code{gdb.MemoryChangedEvent} which indicates that the memory of the
+inferior has been modified by the @value{GDBN} user, for instance via a
+command like @w{@code{set *addr = value}}.  The event has the following
+attributes:
+
+@defvar MemoryChangedEvent.address
+The start address of the changed region.
+@end defvar
+
+@defvar MemoryChangedEvent.length
+Length in bytes of the changed region.
+@end defvar
+
+@item events.register_changed
+Emits @code{gdb.RegisterChangedEvent} which indicates that a register in the
+inferior has been modified by the @value{GDBN} user.
+
+@defvar RegisterChangedEvent.frame
+A gdb.Frame object representing the frame in which the register was modified.
+@end defvar
+@defvar RegisterChangedEvent.regnum
+Denotes which register was modified.
+@end defvar
+
 @end table
 
 @node Threads In Python
index 718393c..25a7af4 100644 (file)
@@ -35,6 +35,7 @@
 #include "ada-lang.h"
 #include "gdbthread.h"
 #include "event-top.h"
+#include "observer.h"
 
 /* If we can't find a function's name from its address,
    we print this instead.  */
@@ -654,6 +655,8 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
       target_values_type = values_type;
     }
 
+  observer_notify_inferior_call_pre (inferior_ptid, funaddr);
+
   /* Determine the location of the breakpoint (and possibly other
      stuff) that the called function will return to.  The SPARC, for a
      function returning a structure or union, needs to make space for
@@ -899,6 +902,8 @@ call_function_by_hand (struct value *function, int nargs, struct value **args)
     e = run_inferior_call (tp, real_pc);
   }
 
+  observer_notify_inferior_call_post (call_thread_ptid, funaddr);
+
   /* Rethrow an error if we got one trying to run the inferior.  */
 
   if (e.reason < 0)
index c0bd9a6..6df92ea 100644 (file)
@@ -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);
index 0b5656b..4d5b895 100644 (file)
@@ -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;
 
index d08b14b..e006763 100644 (file)
@@ -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;
 
index 1b38d55..9af8173 100644 (file)
@@ -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 (file)
index 0000000..beb0598
--- /dev/null
@@ -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 (&register_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);
index 7fa2ca8..67a187c 100644 (file)
@@ -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.  */
 
index 54eebeb..716c0de 100644 (file)
@@ -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)
index ca531e2..1362bd2 100644 (file)
@@ -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
index db5127c..f0bcbf8 100644 (file)
@@ -1,3 +1,11 @@
+2014-12-02  Nick Bull  <nicholaspbull@gmail.com>
+
+       * gdb.python/py-events.py (inferior_call_handler): New.
+       (register_changed_handler, memory_changed_handler): New.
+       (test_events.invoke): Register new handlers.
+       * gdb.python/py-events.exp: Add tests for inferior call,
+       memory_changed and register_changed events.
+
 2014-12-02  Andreas Arnez  <arnez@linux.vnet.ibm.com>
 
        * gdb.base/execl-update-breakpoints.exp: Specify the link address
index c4331fe..1372382 100644 (file)
@@ -79,6 +79,123 @@ all threads stopped"
 
 delete_breakpoints
 
+# Test inferior call events
+
+gdb_test_multiple "info threads" "get current thread" {
+    -re "\[^\n\r\]*process (\[0-9\]+)\[^\n\r\]*do_nothing.*$gdb_prompt $" {
+       set process_id $expect_out(1,string)
+       pass "get current thread"
+    }
+}
+
+gdb_test_multiple "print do_nothing" "get address of do_nothing" {
+    -re "\[^\n\r\]*(0x\[0-9a-f\]+) \<do_nothing\>.*$gdb_prompt $" {
+       set addr $expect_out(1,string)
+       pass "get address of do_nothing"
+    }
+}
+
+set expected [list "event type: pre-call"]
+lappend expected "ptid: \\($process_id, $process_id, 0\\)" "address: $addr"
+lappend expected "event type: post-call"
+lappend expected "ptid: \\($process_id, $process_id, 0\\)" "address: $addr"
+gdb_test_sequence "call do_nothing()" "" $expected
+
+# Test register changed event
+gdb_test_no_output {set $old_sp = $sp}
+gdb_test_sequence {set $sp = 0} "" {
+    "event type: register-changed"
+    "frame: "
+    "num: "
+}
+gdb_test_sequence {set $sp = 1} "" {
+    "event type: register-changed"
+    "frame: "
+    "num: "
+}
+gdb_test_sequence {set $sp = $old_sp} "" {
+    "event type: register-changed"
+    "frame: "
+    "num: "
+}
+
+# Test that no register_changed event is generated on "non-user"
+# modifications
+set test "up"
+gdb_test_multiple {up} $test {
+    -re "event type: register-changed.*\r\n$gdb_prompt $" {
+       fail $test
+    }
+    -re "#1.*in first.*\r\n.*do_nothing.*\r\n$gdb_prompt $" {
+       pass $test
+    }
+}
+
+set test "down"
+gdb_test_multiple {down} $test {
+    -re "event type: register-changed.*\r\n$gdb_prompt $" {
+       fail $test
+    }
+    -re "#0.*do_nothing.* at .*\r\n.*void do_nothing.*\r\n$gdb_prompt $" {
+       pass $test
+    }
+}
+
+set test "step"
+# Note: This will step the inferior out of do_nothing and back into first.
+gdb_test_multiple {step} $test {
+    -re "event type: register-changed.*\r\n$gdb_prompt $" {
+       fail $test
+    }
+    -re "first.* at .*\r\n$gdb_prompt $" {
+       pass $test
+    }
+}
+
+# Test memory changed event
+gdb_test_no_output {set $saved = *(int*) $sp}
+gdb_test_sequence {set *(int*) $sp = 0} "" {
+    "event type: memory-changed"
+    "address: "
+    "length: "
+}
+gdb_test_sequence {set *(int*) $sp = $saved} "" {
+    "event type: memory-changed"
+    "address: "
+    "length: "
+}
+
+# Test that no memory_changed event is generated on breakpoint
+# activity
+set test "break second"
+gdb_test_multiple "break second" $test {
+    -re "event type: memory-changed" {
+       fail $test
+    }
+    -re "Breakpoint (\[0-9\]+) at .*\r\n$gdb_prompt $" {
+       set second_breakpoint $expect_out(1,string)
+       pass $test
+    }
+
+}
+
+set test "continue to breakpoint $second_breakpoint"
+set expected ".*event type: continue.*\r\n"
+append expected ".*event type: stop.*\r\n"
+append expected ".*stop reason: breakpoint.*\r\n"
+append expected ".*all threads stopped.*\r\n$gdb_prompt $"
+
+gdb_test_multiple "continue" $test {
+    -re "event type: memory-changed.*\r\n$gdb_prompt $" {
+       fail $test
+    }
+    -re $expected {
+       pass $test
+    }
+}
+
+gdb_test_no_output "delete $second_breakpoint"
+
 #test exited event.
 gdb_test "continue" ".*event type: continue.*
 .*clear_objfiles\[\r\n\]*progspace: .*py-events.*
index 9af768b..3bc5ff4 100644 (file)
@@ -62,6 +62,30 @@ def clear_objfiles_handler (event):
     print ("event type: clear_objfiles")
     print ("progspace: %s" % (event.progspace.filename))
 
+def inferior_call_handler (event):
+    if (isinstance (event, gdb.InferiorCallPreEvent)):
+        print ("event type: pre-call")
+    elif (isinstance (event, gdb.InferiorCallPostEvent)):
+        print ("event type: post-call")
+    else:
+        assert False
+    print ("ptid: %s" % (event.ptid,))
+    print ("address: 0x%x" % (event.address))
+
+def register_changed_handler (event):
+    assert (isinstance (event, gdb.RegisterChangedEvent))
+    print ("event type: register-changed")
+    assert (isinstance (event.frame, gdb.Frame))
+    print ("frame: %s" % (event.frame))
+    print ("num: %s" % (event.regnum))
+
+def memory_changed_handler (event):
+    assert (isinstance (event, gdb.MemoryChangedEvent))
+    print ("event type: memory-changed")
+    print ("address: %s" % (event.address))
+    print ("length: %s" % (event.length))
+
+
 class test_events (gdb.Command):
     """Test events."""
 
@@ -73,6 +97,9 @@ class test_events (gdb.Command):
         gdb.events.stop.connect (breakpoint_stop_handler)
         gdb.events.exited.connect (exit_handler)
         gdb.events.cont.connect (continue_handler)
+        gdb.events.inferior_call.connect (inferior_call_handler)
+        gdb.events.memory_changed.connect (memory_changed_handler)
+        gdb.events.register_changed.connect (register_changed_handler)
         print ("Event testers registered.")
 
 test_events ()
index 83a74b2..1dac738 100644 (file)
@@ -1169,6 +1169,7 @@ value_assign (struct value *toval, struct value *fromval)
              }
          }
 
+       observer_notify_register_changed (frame, value_reg);
        if (deprecated_register_changed_hook)
          deprecated_register_changed_hook (-1);
        break;