From patchwork Wed Sep 27 15:16:55 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew Burgess X-Patchwork-Id: 76773 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id C65323861873 for ; Wed, 27 Sep 2023 15:17:33 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C65323861873 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1695827853; bh=XTklnIBoqL7yjb7GH+OBmFvCVGenHW/moCR+17G7Z+0=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=jEAe/Id08LApotOYF2KxGVs+4HJXsA2/qG2Hsp/3yEAoy9Uc9Z/eaF/VpERRFTT81 3y1MO8QDlsWTkHWteFrqONeCWfkTAILHeQG/rCCSpcfoISvXFhIi3/CKEfdce7AFbQ l56JRqUWE3fUT3ZMadXAU21MpbBiDCo0DSMwstl4= X-Original-To: gdb-patches@sourceware.org Delivered-To: gdb-patches@sourceware.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 1D69A3856DD6 for ; Wed, 27 Sep 2023 15:17:05 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 1D69A3856DD6 Received: from mail-yw1-f197.google.com (mail-yw1-f197.google.com [209.85.128.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-6-Fvyi-AjnP8qOtHeuoSlxdQ-1; Wed, 27 Sep 2023 11:17:03 -0400 X-MC-Unique: Fvyi-AjnP8qOtHeuoSlxdQ-1 Received: by mail-yw1-f197.google.com with SMTP id 00721157ae682-59f8315aabfso133077317b3.0 for ; Wed, 27 Sep 2023 08:17:03 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1695827822; x=1696432622; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=XTklnIBoqL7yjb7GH+OBmFvCVGenHW/moCR+17G7Z+0=; b=tK4bF+m4fow7zeksB97QFWb3XbzBB4iylea0JQ83W09QLmRZmJ36Gd1iXtemBVkw14 zsIxrklgOD0zJB0X5YruQqrY0H7/EQUkiTmvZAfYe/PM35Z0RjsiichbPr8C0Hzo8qrE rleSrBY6VpCG0BX6rphSuWzJXhXJ1cS0/jjP0jnWj/0Ke71fd3EluuagUeaIfj2oHLO9 o/NBLTd0hR/lTpYoC8bpve7WZpmsosI24eakxBMivPkn57bZLsni8zCiTnLwEm+YwF/U m/ERHQmuavkWEreUMRtProfrOkqf3FCxNGbCl2ZjJbns+ROZOiARIRbMV8Iu/S4IQ3uC fFHQ== X-Gm-Message-State: AOJu0YwjhsNSl0GEdiXkMYl7tfebhmJxH0gWAVvbu+FF7upAxfaqs1Um o0+JlSo+8qXC7wKAnjtSUtUnL4ib8HWfEFUaiP9+wOaBCX8bV5ol6fDR9Nbz5bhp9JqlIjh2HRQ PEwtJP3pVSvdZVF7qUjF6cAGNe+CbpMtLrP4D6T1wCelLMCaqmsbduVo7eZwzg7P9Ze3qQiSYC/ 7khKhxFg== X-Received: by 2002:a81:83d5:0:b0:59b:52d6:9a34 with SMTP id t204-20020a8183d5000000b0059b52d69a34mr2738548ywf.11.1695827821941; Wed, 27 Sep 2023 08:17:01 -0700 (PDT) X-Google-Smtp-Source: AGHT+IG39vngSKIW00RsQ3U28xyqhzcMc4oFEceubZKMgVTFdmHd9CFK9jd5UgUicNBnsJUc4QYPxw== X-Received: by 2002:a81:83d5:0:b0:59b:52d6:9a34 with SMTP id t204-20020a8183d5000000b0059b52d69a34mr2738514ywf.11.1695827821332; Wed, 27 Sep 2023 08:17:01 -0700 (PDT) Received: from localhost ([31.111.84.209]) by smtp.gmail.com with ESMTPSA id p9-20020a0cf549000000b0065b11053445sm2673487qvm.54.2023.09.27.08.17.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 27 Sep 2023 08:17:01 -0700 (PDT) To: gdb-patches@sourceware.org Subject: [PATCHv2] gdb: add Python events for program space addition and removal Date: Wed, 27 Sep 2023 16:16:55 +0100 Message-Id: X-Mailer: git-send-email 2.25.4 In-Reply-To: <634d50951c6a4d50b0aa8dc91758c025738e8c68.1695300249.git.aburgess@redhat.com> References: <634d50951c6a4d50b0aa8dc91758c025738e8c68.1695300249.git.aburgess@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.7 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Andrew Burgess via Gdb-patches From: Andrew Burgess Reply-To: Andrew Burgess Cc: Tom Tromey Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org Sender: "Gdb-patches" Changes in V2: - Fixed a typo in the docs that Tom pointed out, - Changed one of the test patterns after Linaro CI testing spotted a failure, I'm now using a gdb_test_multiple loop rather than gdb_test so that I can more easily ignore lines I'm not interested in. I've been unable to repreduce the exact output that Linaro saw in their CI testing, but I believe the updated test should now pass. I'll leave this here for a few days before pushing. Reviewed-By: Eli Zaretskii --- Initially I just wanted a Python event for when GDB removes a program space, I'm writing a Python extension that caches information for each program space, and need to know when I should discard entries for a particular program space. But, it seemed easy enough to also add an event for when GDB adds a new program space, so I went ahead and added both new events. Of course, we don't currently have an observable for program space addition or removal, so I first needed to add these. After that it's pretty simple to add two new Python events and have these trigger. The two new event registries are: events.new_progspace events.free_progspace These emit NewProgspaceEvent and FreeProgspaceEvent objects respectively, each of these new event types has a 'progspace' attribute that contains the relevant gdb.Progspace object. There's a couple of things to be mindful of. First, it is not possible to catch the NewProgspaceEvent for the very first program space, the one that is created when GDB first starts, as this program space is created before any Python scripts are sourced. In order to allow this event to be caught we would need to defer creating the first program space, and as a consequence the first inferior, until some later time. But, existing scripts could easily depend on there being an initial inferior, so I really don't think we should change that -- and so, we end up with the consequence that we can't catch the event for the first program space. The second, I think minor, issue, is that GDB doesn't clean up its program spaces upon exit -- or at least, they are not cleaned up before Python is shut down. As a result, any program spaces in use at the time GDB exits don't generate a FreeProgspaceEvent. I'm not particularly worried about this for my use case, I'm using the event to ensure that a cache doesn't hold stale entries within a single GDB session. It's also easy enough to add a Python at-exit callback which can do any final cleanup if needed. Finally, when testing, I did hit a slightly weird issue with some of the remote boards (e.g. remote-stdio-gdbserver). As a consequence of this issue I see some output like this in the gdb.log: (gdb) PASS: gdb.python/py-progspace-events.exp: inferior 1 step FreeProgspaceEvent: warning: cannot close "target:/lib64/libm.so.6": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. warning: cannot close "target:/lib64/libc.so.6": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. warning: cannot close "target:/lib64/ld-linux-x86-64.so.2": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. do_parent_stuff () at py-progspace-events.c:41 41 ++global_var; (gdb) PASS: gdb.python/py-progspace-events.exp: step The 'FreeProgspaceEvent ...' line is expected, that's my test Python extension logging the event. What isn't expected are all the blocks like: warning: cannot close "target:/lib64/libm.so.6": Cannot execute this command while the target is running. Use the "interrupt" command to stop the target and then try again. It turns out that this has nothing to do with my changes, this is just a consequence of reading files over the remote protocol. The test forks a child process which GDB stays attached too. When the child exits, GDB cleans up by calling prune_inferiors, which in turn can result in GDB trying to close some files that are open because of the inferior being deleted. If the prune_inferiors call occurs when the remote target is running (and in non-async mode) then GDB will try to send a fileio packet while the remote target is waiting for a stop reply, and the remote target will throw an error, see remote_target::putpkt_binary in remote.c for details. I'm going to look at fixing this, but, as I said, this is nothing to do with this change, I just mention it because I ended up needing to account for these warning messages in one of my tests, and it all looks a bit weird. Approved-By: Tom Tromey --- gdb/NEWS | 7 + gdb/doc/python.texi | 28 ++++ gdb/observable.c | 2 + gdb/observable.h | 7 + gdb/progspace.c | 3 + gdb/python/py-all-events.def | 2 + gdb/python/py-event-types.def | 10 ++ gdb/python/py-progspace.c | 67 ++++++++++ .../gdb.python/py-progspace-events.c | 73 ++++++++++ .../gdb.python/py-progspace-events.exp | 125 ++++++++++++++++++ .../gdb.python/py-progspace-events.py | 29 ++++ 11 files changed, 353 insertions(+) create mode 100644 gdb/testsuite/gdb.python/py-progspace-events.c create mode 100644 gdb/testsuite/gdb.python/py-progspace-events.exp create mode 100644 gdb/testsuite/gdb.python/py-progspace-events.py base-commit: f586e3409b752748bf213520c2dbb0b44e0005d8 diff --git a/gdb/NEWS b/gdb/NEWS index 5b9ca9be30f..84fc87b07de 100644 --- a/gdb/NEWS +++ b/gdb/NEWS @@ -298,6 +298,13 @@ show tui mouse-events class, it signals to gdb that the printer may implement new pretty-printer methods. + ** New event registries gdb.events.new_progspace and + gdb.events.free_progspace, these emit NewProgspaceEvent and + FreeProgspaceEvent event types respectively. Both of these event + types have a single 'progspace' attribute, which is the + gdb.Progspace that is either being added to GDB, or removed from + GDB. + *** Changes in GDB 13 * MI version 1 is deprecated, and will be removed in GDB 14. diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi index 5e88fd09e48..55af6e291bc 100644 --- a/gdb/doc/python.texi +++ b/gdb/doc/python.texi @@ -3929,6 +3929,34 @@ The @code{gdb.TargetConnection} that is being removed. @end defvar +@item events.new_progspace +This is emitted when @value{GDBN} adds a new program space +(@pxref{Progspaces In Python,,Program Spaces In Python}). The event +is of type @code{gdb.NewProgspaceEvent}, and has a single read-only +attribute: + +@defvar NewProgspaceEvent.progspace +The @code{gdb.Progspace} that was added to @value{GDBN}. +@end defvar + +No @code{NewProgspaceEvent} is emitted for the very first program +space, which is assigned to the first inferior. This first program +space is created within @value{GDBN} before any Python scripts are +sourced. + +@item events.free_progspace +This is emitted when @value{GDBN} removes a program space +(@pxref{Progspaces In Python,,Program Spaces In Python}), for example +as a result of the @kbd{remove-inferiors} command +(@pxref{remove_inferiors_cli,,@kbd{remove-inferiors}}). The event is +of type @code{gdb.FreeProgspaceEvent}, and has a single read-only +attribute: + +@defvar FreeProgspaceEvent.progspace +The @code{gdb.Progspace} that is about to be removed from +@value{GDBN}. +@end defvar + @end table @node Threads In Python diff --git a/gdb/observable.c b/gdb/observable.c index 33e51223cf4..93a842e911f 100644 --- a/gdb/observable.c +++ b/gdb/observable.c @@ -72,6 +72,8 @@ DEFINE_OBSERVABLE (gdb_exiting); DEFINE_OBSERVABLE (connection_removed); DEFINE_OBSERVABLE (target_pre_wait); DEFINE_OBSERVABLE (target_post_wait); +DEFINE_OBSERVABLE (new_program_space); +DEFINE_OBSERVABLE (free_program_space); } /* namespace observers */ } /* namespace gdb */ diff --git a/gdb/observable.h b/gdb/observable.h index 4ea203c6fc3..84e9b401e95 100644 --- a/gdb/observable.h +++ b/gdb/observable.h @@ -31,6 +31,7 @@ struct inferior; struct process_stratum_target; struct target_ops; struct trace_state_variable; +struct program_space; namespace gdb { @@ -233,6 +234,12 @@ extern observable target_pre_wait; /* About to leave target_wait (). */ extern observable target_post_wait; +/* New program space PSPACE was created. */ +extern observable new_program_space; + +/* The program space PSPACE is about to be deleted. */ +extern observable free_program_space; + } /* namespace observers */ } /* namespace gdb */ diff --git a/gdb/progspace.c b/gdb/progspace.c index 5cf8334ee67..1dbcd5875dd 100644 --- a/gdb/progspace.c +++ b/gdb/progspace.c @@ -28,6 +28,7 @@ #include "inferior.h" #include #include "cli/cli-style.h" +#include "observable.h" /* The last program space number assigned. */ static int last_program_space_num = 0; @@ -98,6 +99,7 @@ program_space::program_space (address_space *aspace_) aspace (aspace_) { program_spaces.push_back (this); + gdb::observers::new_program_space.notify (this); } /* See progspace.h. */ @@ -106,6 +108,7 @@ program_space::~program_space () { gdb_assert (this != current_program_space); + gdb::observers::free_program_space.notify (this); remove_program_space (this); scoped_restore_current_program_space restore_pspace; diff --git a/gdb/python/py-all-events.def b/gdb/python/py-all-events.def index aa28f2c6f8b..ce0249f8fed 100644 --- a/gdb/python/py-all-events.def +++ b/gdb/python/py-all-events.def @@ -42,3 +42,5 @@ GDB_PY_DEFINE_EVENT(breakpoint_modified) GDB_PY_DEFINE_EVENT(before_prompt) GDB_PY_DEFINE_EVENT(gdb_exiting) GDB_PY_DEFINE_EVENT(connection_removed) +GDB_PY_DEFINE_EVENT(new_progspace) +GDB_PY_DEFINE_EVENT(free_progspace) diff --git a/gdb/python/py-event-types.def b/gdb/python/py-event-types.def index 395d6c07447..450132e2a2e 100644 --- a/gdb/python/py-event-types.def +++ b/gdb/python/py-event-types.def @@ -125,3 +125,13 @@ GDB_PY_DEFINE_EVENT_TYPE (connection, "ConnectionEvent", "GDB connection added or removed object", event_object_type); + +GDB_PY_DEFINE_EVENT_TYPE (new_progspace, + "NewProgspaceEvent", + "GDB new Progspace event object", + event_object_type); + +GDB_PY_DEFINE_EVENT_TYPE (free_progspace, + "FreeProgspaceEvent", + "GDB free Progspace event object", + event_object_type); diff --git a/gdb/python/py-progspace.c b/gdb/python/py-progspace.c index b98ac8dde61..18328e33fb6 100644 --- a/gdb/python/py-progspace.c +++ b/gdb/python/py-progspace.c @@ -26,6 +26,8 @@ #include "arch-utils.h" #include "solib.h" #include "block.h" +#include "observable.h" +#include "py-event.h" struct pspace_object { @@ -553,9 +555,74 @@ gdbpy_is_progspace (PyObject *obj) return PyObject_TypeCheck (obj, &pspace_object_type); } +/* Helper function to emit NewProgspaceEvent (when ADDING_P is true) or + FreeProgspaceEvent events (when ADDING_P is false). */ + +static void +gdbpy_program_space_event (program_space *pspace, bool adding_p) +{ + if (!gdb_python_initialized) + return; + + gdbpy_enter enter_py; + + eventregistry_object *registry; + PyTypeObject *event_type; + if (adding_p) + { + registry = gdb_py_events.new_progspace; + event_type = &new_progspace_event_object_type; + } + else + { + registry = gdb_py_events.free_progspace; + event_type = &free_progspace_event_object_type; + } + + if (evregpy_no_listeners_p (registry)) + return; + + gdbpy_ref<> pspace_obj = pspace_to_pspace_object (pspace); + if (pspace_obj == nullptr) + { + gdbpy_print_stack (); + return; + } + + gdbpy_ref<> event = create_event_object (event_type); + if (event == nullptr + || evpy_add_attribute (event.get (), "progspace", + pspace_obj.get ()) < 0 + || evpy_emit_event (event.get (), registry) < 0) + gdbpy_print_stack (); +} + + +/* Emit a NewProgspaceEvent to indicate PSPACE has been created. */ + +static void +gdbpy_new_program_space_event (program_space *pspace) +{ + gdbpy_program_space_event (pspace, true); +} + +/* Emit a FreeProgspaceEvent to indicate PSPACE is just about to be removed + from GDB. */ + +static void +gdbpy_free_program_space_event (program_space *pspace) +{ + gdbpy_program_space_event (pspace, false); +} + static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION gdbpy_initialize_pspace (void) { + gdb::observers::new_program_space.attach (gdbpy_new_program_space_event, + "py-progspace"); + gdb::observers::free_program_space.attach (gdbpy_free_program_space_event, + "py-progspace"); + if (PyType_Ready (&pspace_object_type) < 0) return -1; diff --git a/gdb/testsuite/gdb.python/py-progspace-events.c b/gdb/testsuite/gdb.python/py-progspace-events.c new file mode 100644 index 00000000000..6684cf8ac0a --- /dev/null +++ b/gdb/testsuite/gdb.python/py-progspace-events.c @@ -0,0 +1,73 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2023 Free Software Foundation, Inc. + + 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 +#include +#include +#include + +/* This gives the inferior something to do. */ +volatile int global_var = 0; + +void +breakpt () +{ /* Nothing. */ } + +void +do_child_stuff () +{ + breakpt (); + ++global_var; +} + +void +do_parent_stuff () +{ + breakpt (); + ++global_var; +} + +void +create_child () +{ + int stat; + pid_t wpid; + breakpt (); + pid_t pid = fork (); + assert (pid != -1); + + if (pid == 0) + { + /* Child. */ + do_child_stuff (); + return; + } + + /* Parent. */ + do_parent_stuff (); + wpid = waitpid (pid, &stat, 0); + assert (wpid == pid); +} + + + +int +main () +{ + create_child (); + return 0; +} diff --git a/gdb/testsuite/gdb.python/py-progspace-events.exp b/gdb/testsuite/gdb.python/py-progspace-events.exp new file mode 100644 index 00000000000..60ae290c0b2 --- /dev/null +++ b/gdb/testsuite/gdb.python/py-progspace-events.exp @@ -0,0 +1,125 @@ +# Copyright (C) 2023 Free Software Foundation, Inc. + +# 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 . + +# This file is part of the GDB testsuite. It tests the program space +# related events in the Python API. + +load_lib gdb-python.exp + +require allow_python_tests + +standard_testfile + +if {[prepare_for_testing "preparing" $testfile $srcfile] == -1} { + return -1 +} + +set pyfile [gdb_remote_download host ${srcdir}/${subdir}/py-progspace-events.py] +gdb_test_no_output "source ${pyfile}" "load python file" + +if {![runto_main]} { + return +} + +gdb_breakpoint breakpt + +gdb_continue_to_breakpoint "run to breakpt function" + +gdb_test_no_output "set detach-on-fork off" + +# Continue until the parent process forks and a new child is added. +# Done this way so we can count the new progspace events; we expect to +# see exactly one. +set new_progspace_event_count 0 +gdb_test_multiple "continue" "continue until child process appears" { + -re "^NewProgspaceEvent: \r\n" { + # This is a correctly formed event line. + incr new_progspace_event_count + exp_continue + } + + -re "^NewProgspaceEvent:\[^\r\n\]+\r\n" { + # This is an incorrectly formed event line. + fail $gdb_test_name + } + + -re "^$gdb_prompt $" { + pass $gdb_test_name + } + + -re "^\[^\r\n\]*\r\n" { + exp_continue + } +} + +gdb_assert { $new_progspace_event_count == 1 } \ + "only a single new progspace event seen" + +# Switch to inferior 2 and continue until we hit breakpt. +gdb_test "inferior 2" "\\\[Switching to inferior 2 .*" +gdb_continue_to_breakpoint "run to breakpt in inferior 2" + +# Let inferior 2 exit. The new program space is not removed at this +# point. +gdb_test "continue" \ + [multi_line \ + "^Continuing\\." \ + "\\\[Inferior $decimal \[^\r\n\]+ exited normally\\\]"] \ + "continue until inferior 2 exits" + +gdb_test "inferior 1" "\\\[Switching to inferior 1 .*" + +# Step the inferior. During this process GDB will prune the now +# defunct inferior, which deletes its program space, which should +# trigger the FreeProgspaceEvent. +# +# However, there is a slight problem. When the target is remote, and +# GDB is accessing files using remote fileio, then GDB will attempt to +# prune the inferior at a point in time when the remote target is +# waiting for a stop reply. Pruning an inferior causes GDB to close +# files associated with that inferior. +# +# In non-async mode we can't send fileio packets while waiting for a +# stop reply, so the attempts to close files fails, and this shows up +# as an error. +# +# As this error has nothing to do with the feature being tested here, +# we just accept the error message, the important part is the +# 'FreeProgspaceEvent' string, so long as that appears (just once) +# then the test is a success. +set warning_msg \ + [multi_line \ + "warning: cannot close \"\[^\r\n\]+\": Cannot execute this command while the target is running\\." \ + "Use the \"interrupt\" command to stop the target" \ + "and then try again\\."] + +gdb_test "step" \ + [multi_line \ + "^FreeProgspaceEvent: (?:\r\n$warning_msg)*" \ + "do_parent_stuff \\(\\) at \[^\r\n\]+" \ + "$decimal\\s+\[^\r\n\]+"] + +# Let this inferior run to completion. +gdb_continue_to_end + +# Check the program space events trigger when a new inferior is +# manually added and removed. +gdb_test "add-inferior" \ + [multi_line \ + "^NewProgspaceEvent: " \ + "\\\[New inferior 3\\\]" \ + "Added inferior 3\[^\r\n\]*"] +gdb_test "remove-inferior 3" \ + "^FreeProgspaceEvent: " diff --git a/gdb/testsuite/gdb.python/py-progspace-events.py b/gdb/testsuite/gdb.python/py-progspace-events.py new file mode 100644 index 00000000000..3abb421cffa --- /dev/null +++ b/gdb/testsuite/gdb.python/py-progspace-events.py @@ -0,0 +1,29 @@ +# Copyright (C) 2023 Free Software Foundation, Inc. + +# 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 . + +# This file is part of the GDB testsuite, it registers listeners for +# the Progspace related events. + +import gdb +import gdb.events + +def new_progspace(event): + print("NewProgspaceEvent: %s" % str(event.progspace)) + +def free_progspace(event): + print("FreeProgspaceEvent: %s" % str(event.progspace)) + +gdb.events.new_progspace.connect(new_progspace) +gdb.events.free_progspace.connect(free_progspace)