From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 28231 invoked by alias); 9 Dec 2013 17:48:07 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 28221 invoked by uid 89); 9 Dec 2013 17:48:07 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.5 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,RCVD_IN_DNSWL_LOW,SPF_PASS autolearn=ham version=3.3.2 X-HELO: mail-wi0-f169.google.com Received: from Unknown (HELO mail-wi0-f169.google.com) (209.85.212.169) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Mon, 09 Dec 2013 17:48:04 +0000 Received: by mail-wi0-f169.google.com with SMTP id hn6so4163109wib.0 for ; Mon, 09 Dec 2013 09:47:55 -0800 (PST) X-Received: by 10.180.212.98 with SMTP id nj2mr15399001wic.52.1386611274945; Mon, 09 Dec 2013 09:47:54 -0800 (PST) Received: from [192.168.123.180] (ssh.greglaw.net. [82.71.15.62]) by mx.google.com with ESMTPSA id q19sm23152742wiw.4.2013.12.09.09.47.53 for (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Mon, 09 Dec 2013 09:47:53 -0800 (PST) Message-ID: <52A60249.5010909@gmail.com> Date: Mon, 09 Dec 2013 17:48:00 -0000 From: Nick Bull User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:24.0) Gecko/20100101 Thunderbird/24.1.1 MIME-Version: 1.0 To: gdb-patches@sourceware.org Subject: Re: [PATCH v2] Events when inferior is modified References: <51CDBD48.6010903@gmail.com> <87k3k7kbdy.fsf@fleche.redhat.com> <528A0A83.1080203@gmail.com> <52931CEC.7040407@redhat.com> In-Reply-To: Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit X-SW-Source: 2013-12/txt/msg00348.txt.bz2 On 25 November 2013 09:48, Phil Muldoon wrote: > On 18/11/13 12:39, Nick Bull wrote: > >> This patch adds new observers, and corresponding Python events, for >> various actions on an inferior: calling a function (by hand), >> modifying registers or modifying memory. > > Thanks just a few nits and some questions. I did not see tests for > these, and also, documentation? In any case, both are needed. Now with the nits addressed, rejigging to use the existing memory_changed observer, some test coverage and documentation. make check ran without regressions. Nick gdb/ChangeLog 2013-12-09 Nick Bull * Makefile.in: add py-infcallevent.c / py-infcallevent.o. * doc/observer.texi (inferior_call_pre, inferior_call_post 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-infcallevent.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/python-internal.h: (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/testsuite/ChangeLog 2013-12-09 Nick Bull * gdb.python/py-events.py (inferior_fn_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. diff --git a/gdb/Makefile.in b/gdb/Makefile.in index be30dfd..40e9875 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -296,6 +296,7 @@ SUBDIR_PYTHON_OBS = \ py-framefilter.o \ py-function.o \ py-gdb-readline.o \ + py-infcallevent.o \ py-inferior.o \ py-infthread.o \ py-lazy-string.o \ @@ -332,6 +333,7 @@ SUBDIR_PYTHON_SRCS = \ python/py-framefilter.c \ python/py-function.c \ python/py-gdb-readline.c \ + python/py-infcallevent.c \ python/py-inferior.c \ python/py-infthread.c \ python/py-lazy-string.c \ @@ -2217,6 +2219,10 @@ py-gdb-readline.o: $(srcdir)/python/py-gdb-readline.c $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-gdb-readline.c $(POSTCOMPILE) +py-infcallevent.o: $(srcdir)/python/py-infcallevent.c + $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-infcallevent.c + $(POSTCOMPILE) + py-inferior.o: $(srcdir)/python/py-inferior.c $(COMPILE) $(PYTHON_CFLAGS) $(srcdir)/python/py-inferior.c $(POSTCOMPILE) diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index 87d5145..f4adef1 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -25808,6 +25808,30 @@ A reference to the object file (@code{gdb.Objfile}) which has been loaded. @xref{Objfiles In Python}, for details of the @code{gdb.Objfile} object. @end defvar +@item inferior_call_pre +Emits @code{gdb.InferiorCallPreEvent} which indicates that a function in +the inferior is about to be called. + +@item inferior_call_post +Emits @code{gdb.InferiorCallPostEvent} which indicates that a function in +the inferior has returned. + +@item memory_changed +Emits @code{gdb.MemoryChangedEvent} which indicates that the memory of the +inferior has been modified by the GDB user, for instance via a command like +@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 register_changed +Emits @code{gdb.RegisterChangedEvent} which indicates that a register in the +inferior has been modified by the GDB user. + @end table @node Threads In Python diff --git a/gdb/doc/observer.texi b/gdb/doc/observer.texi index f753965..c20fec5 100644 --- a/gdb/doc/observer.texi +++ b/gdb/doc/observer.texi @@ -253,6 +253,18 @@ 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 (void) +An inferior function is about to be called. +@end deftypefun + +@deftypefun void inferior_call_post (void) +An inferior function has just been called. +@end deftypefun + +@deftypefun void register_changed (void) +One or more registers in the inferior have been modified. +@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. diff --git a/gdb/infcall.c b/gdb/infcall.c index 212997f..7c1a5ae 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -36,6 +36,7 @@ #include "ada-lang.h" #include "gdbthread.h" #include "exceptions.h" +#include "observer.h" /* If we can't find a function's name from its address, we print this instead. */ @@ -611,6 +612,8 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) target_values_type = values_type; } + observer_notify_inferior_call_pre (); + /* 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 @@ -844,6 +847,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 (); + /* Rethrow an error if we got one trying to run the inferior. */ if (e.reason < 0) diff --git a/gdb/python/py-event.h b/gdb/python/py-event.h index f0ff629..c17079d 100644 --- a/gdb/python/py-event.h +++ b/gdb/python/py-event.h @@ -105,6 +105,15 @@ typedef struct extern int emit_continue_event (ptid_t ptid); extern int emit_exited_event (const LONGEST *exit_code, struct inferior *inf); +typedef enum +{ + inferior_call_pre, + inferior_call_post, +} inferior_call_kind; + +extern int emit_inferior_call_event (inferior_call_kind kind); +extern int emit_register_changed_event (void); +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 4ec3832..d158211 100644 --- a/gdb/python/py-events.h +++ b/gdb/python/py-events.h @@ -46,6 +46,9 @@ typedef struct eventregistry_object *cont; eventregistry_object *exited; eventregistry_object *new_objfile; + 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 1ff3022..76f923b 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-infcallevent.c b/gdb/python/py-infcallevent.c new file mode 100644 index 0000000..4c8505d --- /dev/null +++ b/gdb/python/py-infcallevent.c @@ -0,0 +1,172 @@ +/* Python interface to inferior function events. + + Copyright (C) 2013 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 . */ + +#include "defs.h" +#include "py-event.h" + +static PyTypeObject inferior_call_pre_event_object_type; +static PyTypeObject inferior_call_post_event_object_type; +static PyTypeObject register_changed_event_object_type; +static PyTypeObject memory_changed_event_object_type; + +static PyObject * +create_inferior_call_event_object (int flag) +{ + PyObject * event; + + 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; + } + + return event; +} + +static PyObject * +create_register_changed_event_object (void) +{ + PyObject * event; + + event = create_event_object (®ister_changed_event_object_type); + + return event; +} + +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; + + event = create_event_object (&memory_changed_event_object_type); + + if (!event) + goto fail; + + addr_obj = PyLong_FromLongLong (addr); + if (addr_obj == NULL) + goto fail; + + failed = evpy_add_attribute (event, "address", addr_obj) < 0; + Py_DECREF (addr_obj); + if (failed) + goto fail; + + len_obj = PyLong_FromLong (len); + if (len_obj == NULL) + goto fail; + + failed = evpy_add_attribute (event, "length", len_obj) < 0; + Py_DECREF (len_obj); + if (failed) + goto fail; + + return event; + + fail: + Py_XDECREF (addr_obj); + Py_XDECREF (event); + + 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) +{ + PyObject *event; + + if (evregpy_no_listeners_p (gdb_py_events.inferior_call)) + return 0; + + event = create_inferior_call_event_object (flag); + if (event != NULL) + return evpy_emit_event (event, gdb_py_events.inferior_call); + return -1; +} + +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; +} + +int +emit_register_changed_event (void) +{ + PyObject *event; + + if (evregpy_no_listeners_p (gdb_py_events.register_changed)) + return 0; + + event = create_register_changed_event_object (); + 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-inferior.c b/gdb/python/py-inferior.c index 1a1b774..28f6f7d 100644 --- a/gdb/python/py-inferior.c +++ b/gdb/python/py-inferior.c @@ -118,6 +118,58 @@ python_on_resume (ptid_t ptid) } static void +python_on_inferior_call_pre (void) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (target_gdbarch (), current_language); + + if (emit_inferior_call_event (inferior_call_pre) < 0) + gdbpy_print_stack (); + + do_cleanups (cleanup); +} + +static void +python_on_inferior_call_post (void) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (target_gdbarch (), current_language); + + if (emit_inferior_call_event (inferior_call_post) < 0) + gdbpy_print_stack (); + + do_cleanups (cleanup); +} + +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); +} + +static void +python_on_register_change (void) +{ + struct cleanup *cleanup; + + cleanup = ensure_python_env (target_gdbarch (), current_language); + + if (emit_register_changed_event () < 0) + gdbpy_print_stack (); + + do_cleanups (cleanup); +} + +static void python_inferior_exit (struct inferior *inf) { struct cleanup *cleanup; @@ -794,6 +846,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/python-internal.h b/gdb/python/python-internal.h index 125670e..8eba303 100644 --- a/gdb/python/python-internal.h +++ b/gdb/python/python-internal.h @@ -393,6 +393,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 1873936..85cbefa 100644 --- a/gdb/python/python.c +++ b/gdb/python/python.c @@ -1684,6 +1684,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 diff --git a/gdb/testsuite/gdb.python/py-events.exp b/gdb/testsuite/gdb.python/py-events.exp index 390a2ba..1027866 100644 --- a/gdb/testsuite/gdb.python/py-events.exp +++ b/gdb/testsuite/gdb.python/py-events.exp @@ -79,6 +79,26 @@ all threads stopped" delete_breakpoints +# Test inferior call events +gdb_test "call do_nothing()" ".*event type: pre-call.* +.*event type: continue.* +.*event type: post-call.*" + +# Test register changed event +gdb_test_no_output {set $old_sp = $sp} +gdb_test {set $sp = 0} ".*event type: register-changed.*" +gdb_test {set $sp = 1} ".*event type: register-changed.*" +gdb_test {set $sp = $old_sp} ".*event type: register-changed.*" + +# Test memory changed event +gdb_test_no_output {set $saved = *(int*) $sp} +gdb_test {set *(int*) $sp = 0} ".*event type: memory-changed.* +.*address: .* +.*length: .*" +gdb_test {set *(int*) $sp = $saved} ".*event type: memory-changed.* +.*address: .* +.*length: .*" + #test exited event. gdb_test "continue" ".*event type: continue.* .*event type: exit.* diff --git a/gdb/testsuite/gdb.python/py-events.py b/gdb/testsuite/gdb.python/py-events.py index 7601ca1..5586961 100644 --- a/gdb/testsuite/gdb.python/py-events.py +++ b/gdb/testsuite/gdb.python/py-events.py @@ -57,6 +57,25 @@ def new_objfile_handler (event): print ("event type: new_objfile") print ("new objfile name: %s" % (event.new_objfile.filename)) +def inferior_fn_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 + +def register_changed_handler (event): + assert (isinstance (event, gdb.RegisterChangedEvent)) + print ("event type: register-changed") + +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.""" @@ -68,6 +87,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_fn_handler) + gdb.events.memory_changed.connect(memory_changed_handler) + gdb.events.register_changed.connect(register_changed_handler) print ("Event testers registered.") test_events () diff --git a/gdb/valops.c b/gdb/valops.c index d43c758..7c90b4e 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -1210,6 +1210,7 @@ value_assign (struct value *toval, struct value *fromval) } } + observer_notify_register_changed (); if (deprecated_register_changed_hook) deprecated_register_changed_hook (-1); break;