From patchwork Tue Dec 2 19:19:51 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Doug Evans X-Patchwork-Id: 4037 Received: (qmail 26743 invoked by alias); 2 Dec 2014 19:20:02 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 26634 invoked by uid 89); 2 Dec 2014 19:19:59 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.8 required=5.0 tests=AWL, BAYES_00, RCVD_IN_DNSWL_LOW, SPF_PASS, T_RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mail-ie0-f201.google.com Received: from mail-ie0-f201.google.com (HELO mail-ie0-f201.google.com) (209.85.223.201) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Tue, 02 Dec 2014 19:19:55 +0000 Received: by mail-ie0-f201.google.com with SMTP id rp18so1471424iec.2 for ; Tue, 02 Dec 2014 11:19:53 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:mime-version:content-type :content-transfer-encoding:message-id:date:to:cc:subject:in-reply-to :references; bh=+Ge5nj/XfOXmG8A74v+FrIYOU4ULgyOqSnZbw4egfPg=; b=D2/aXEHT2TTKP1wnfMvqQcuqFf+fAg/iXqhidVgSAnv5DkX1cXKccz2p8q9vj3DaKH l33nSmaeMXVnGFJ7s6VMC0EK4YcauwOG2LQmwP/6N2S58h1bE6Tl05/FFis4HEHbiVRu RDgijVdNfiqnY66gUHAr3kL9/SGlcurlpP4GH9tRTbXRKzMM73pZvchxmkzPdoEOIs7A eveJA9y4U3gXEwNkw/RBMm1Y5xRFDKkUjYxqgLFmWrCeTCqLSNxirhp/AOzx67WkrsuO Mmy7pYncO+ZmwffePdRnA46sar1IMDLiOWjVnKx1Fw9TLk7N/1DQtOusIL/oRrbmZDgC xiOA== X-Gm-Message-State: ALoCoQkYUupj0+begC5PKQUCRANsmyeeFkhGSHxF1o5WvWgOBzpN+gORv3jTzPWkhLL25T5oHLih X-Received: by 10.182.85.170 with SMTP id i10mr902484obz.36.1417547993359; Tue, 02 Dec 2014 11:19:53 -0800 (PST) Received: from corpmail-nozzle1-1.hot.corp.google.com ([100.108.1.104]) by gmr-mx.google.com with ESMTPS id s23si875386yhf.0.2014.12.02.11.19.52 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 02 Dec 2014 11:19:53 -0800 (PST) Received: from ruffy2.mtv.corp.google.com ([172.17.128.107]) by corpmail-nozzle1-1.hot.corp.google.com with ESMTP id dhRVYvxb.1; Tue, 02 Dec 2014 11:19:53 -0800 From: Doug Evans MIME-Version: 1.0 Message-ID: <21630.4311.741887.195958@ruffy2.mtv.corp.google.com> Date: Tue, 2 Dec 2014 11:19:51 -0800 To: Nick Bull Cc: gdb-patches , Pedro Alves Subject: Re: [PATCH v8] Events when inferior is modified In-Reply-To: <546DC41F.8020209@gmail.com> References: <5419C597.4000300@gmail.com> <542C3F4D.70104@redhat.com> <5441432B.5040103@gmail.com> <21569.29405.219428.940000@ruffy.mtv.corp.google.com> <21569.30068.738159.240720@ruffy.mtv.corp.google.com> <5447A5A1.7040708@gmail.com> <546A3AD5.7020508@gmail.com> <546B75B9.1050407@gmail.com> <546DC41F.8020209@gmail.com> X-IsSubscribed: yes Nick Bull writes: > > > On 20/11/14 00:21, Doug Evans wrote: > > On Tue, Nov 18, 2014 at 8:37 AM, Nick Bull wrote: > >> On 17/11/14 21:24, Doug Evans wrote: > >>> Hi. > >>> > >>> Let's go with ptids. > >> > >> Doug, > >> > >> Thanks. So is this version of the patch now good to apply? Note that I don't have > >> push access so will need someone to commit it on my behalf. > > > > Hi. > > > > I gave the patch one last look-over. > > It's almost good to apply but what remains is whitespace and a file name change. > > > > I wouldn't expect to find the register/memory change events in py-infcallevent.c > > so how about naming the file py-infevents.c? > > > > I'll make those changes and commit. > > [Saves you a round trip.] > > Excellent. Thanks to you and everyone else for your help. Here is what I committed. I tweaked a few things: - updated copyright year in one file - hardcoded line number in py-events.exp - ChangeLog - inferior_fn_handle -> inferior_call_handler - whitespace - py-infcallevent.c -> py-infevents.c I also forgot to set the git Author before pushing it upstream, so I reverted and recommitted with the correct Author. [I know one can change the author of the most recent commit with git commit --amend, but I had already pushed it upstream, and I wasn't sure of a simple way of fixing things without reverting/recommiting.] 2014-12-02 Nick Bull * 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 2014-12-02 Nick Bull * python.texi (Events In Python): Document new events InferiorCallPreEvent, InferiorCallPostEvent, MemoryChangedEvent and RegisterChangedEvent. gdb/testsuite/ChangeLog 2014-12-02 Nick Bull * 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. diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 1da8af6..81c8c94 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -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) diff --git a/gdb/NEWS b/gdb/NEWS index d38266f..7262502 100644 --- 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. diff --git a/gdb/doc/observer.texi b/gdb/doc/observer.texi index 2757587..7c4af6b 100644 --- a/gdb/doc/observer.texi +++ b/gdb/doc/observer.texi @@ -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. diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi index 5b35306..63db2b2 100644 --- a/gdb/doc/python.texi +++ b/gdb/doc/python.texi @@ -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 diff --git a/gdb/infcall.c b/gdb/infcall.c index 718393c..25a7af4 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -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) 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 . */ + +#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 1399322..17d5a2a 100644 --- a/gdb/python/py-infthread.c +++ b/gdb/python/py-infthread.c @@ -137,23 +137,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 (). @@ -235,6 +222,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. */ PyObject * 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 diff --git a/gdb/testsuite/gdb.python/py-events.exp b/gdb/testsuite/gdb.python/py-events.exp index c4331fe..1372382 100644 --- a/gdb/testsuite/gdb.python/py-events.exp +++ b/gdb/testsuite/gdb.python/py-events.exp @@ -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\]+) \.*$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.* diff --git a/gdb/testsuite/gdb.python/py-events.py b/gdb/testsuite/gdb.python/py-events.py index 9af768b..3bc5ff4 100644 --- a/gdb/testsuite/gdb.python/py-events.py +++ b/gdb/testsuite/gdb.python/py-events.py @@ -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 () diff --git a/gdb/valops.c b/gdb/valops.c index 83a74b2..1dac738 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -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;