From patchwork Mon Oct 30 16:11:11 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Andrew Burgess X-Patchwork-Id: 78773 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 F33BF3875447 for ; Mon, 30 Oct 2023 16:12:20 +0000 (GMT) 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.129.124]) by sourceware.org (Postfix) with ESMTPS id 16A993852769 for ; Mon, 30 Oct 2023 16:11:32 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 16A993852769 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 16A993852769 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698682294; cv=none; b=Yn/fta8TKBbocaMqyublRMTigUd70dnLwhN9ZTB/Pm5m6EIrs5+5sTs+vPxb+vx4oaRtmy678LaQuXIsa2ptZyvEBd95w/dzUNUMuuu/fiwkOqjTyqZw4wT/uvxZXkQYh0A9C/t+MqphVFxx18mP6EpIG7smzhiA5kPQ0vWqVHE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698682294; c=relaxed/simple; bh=9EnNwskC+UeShi3bg+mCtHyccmGsrMF04BS+eGKYwjo=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=IimPYto+hQbbH3q+769HxlhVmBv5AVm1zDCjK3r8hWmRDAXoeoGNeZvo075yVMTRyf1a/MpmMdjKFWAwnoQhWzQXctAdoFEDKhdrzFMvzYJxwufzetCEV6AeDhPCNURUdXDPLQ3uA2CAEpxLmWVfK44QCoIlJo2yg2m6fkjcPFc= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1698682291; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Q/ieAZl/1jyxDfMGJu90lUKVC+0u6idDKrnY98hO84s=; b=ggTiGPDytT4gI9gWeO7F+d5UVatr/DHVEz3JuV3iBNET0xlh37OFry7xGP10QVQkTvuOL8 SCodzZJqaA3IFw71I6LWPxjzMb9fzRKATSUyHHetBlxeK6vjhkLD4AH4OBsfgnAhq6l67k VSf2cpTEiEVRyv3NVOLDfUHyX2srxMo= Received: from mail-lf1-f72.google.com (mail-lf1-f72.google.com [209.85.167.72]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-281-aL0DuzPGMLOGbce4fTrrWw-1; Mon, 30 Oct 2023 12:11:29 -0400 X-MC-Unique: aL0DuzPGMLOGbce4fTrrWw-1 Received: by mail-lf1-f72.google.com with SMTP id 2adb3069b0e04-507a3426041so5752554e87.0 for ; Mon, 30 Oct 2023 09:11:29 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698682288; x=1699287088; 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=Q/ieAZl/1jyxDfMGJu90lUKVC+0u6idDKrnY98hO84s=; b=QIIMR6BS0ZLQ3n7uomJhWC8CRTq8BIjQmh13F9nCbkvbLbfbFapK+2Yl/4qwWsg9+U c5diFrPB0VeSKy3xoFVgQQYR8/eXc6Im2LUTf6L7ecThK3Xjh1N4bPnwNKetEvT88jp4 eYCmroHOxvgzXs6l0Fj3/Wi9ByTre/pqwv9eyObwc8eFUgCDUjgyOfIOYPvxWo286XeC RzAIE2vpOb+7MTbQURwnGSmQ2aiEgdVtxKudtNNn3zN6FeNvsIqJmUKFC1RQcEEDOBcX xM8OslhCBEd6opoQZInuAzMEQXBw/rDLmCN23a242wa171QVs3CB54vU1UeG/KRiPoEY DmGg== X-Gm-Message-State: AOJu0Ywi6jMFfwLEaVaKYVtIB9VICg8r3xxYrEVxsiuwuFwrOCgWyStj fXgLkJbtgt4Z3pkB7KGt+HY3qAT44U719fM8bEUqZbxEKRJUN6kbtzouL4q3WWLxZbQwA4pJro0 m+LaoqsYJ6qjGAL16/zg/ilGwX01gTco+kGuI8/mXgTWvJCzwW/Y7cNH/8Tacum256K7d5t/0Fs PZrKGghQ== X-Received: by 2002:a05:6512:3b10:b0:507:9b70:1f0e with SMTP id f16-20020a0565123b1000b005079b701f0emr9313415lfv.24.1698682287853; Mon, 30 Oct 2023 09:11:27 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHmGtKMRq40f6ymnLXa0m/Xs1Obz4jpsCJonYqmiYyabY2KYkbVnEEgdwJDbXLCv7Of84cJBg== X-Received: by 2002:a05:6512:3b10:b0:507:9b70:1f0e with SMTP id f16-20020a0565123b1000b005079b701f0emr9313381lfv.24.1698682287236; Mon, 30 Oct 2023 09:11:27 -0700 (PDT) Received: from localhost ([31.111.84.209]) by smtp.gmail.com with ESMTPSA id fd10-20020a056402388a00b0053e5a1bf77dsm6301685edb.88.2023.10.30.09.11.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 30 Oct 2023 09:11:26 -0700 (PDT) From: Andrew Burgess To: gdb-patches@sourceware.org Cc: Andrew Burgess Subject: [PATCHv6 07/10] gdb: don't set breakpoint::pspace for in create_breakpoint Date: Mon, 30 Oct 2023 16:11:11 +0000 Message-Id: X-Mailer: git-send-email 2.25.4 In-Reply-To: References: MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-11.9 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_H4, 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: , Errors-To: gdb-patches-bounces+patchwork=sourceware.org@sourceware.org While working on the previous commit, I ran into this code within create_breakpoint: if ((type_wanted != bp_breakpoint && type_wanted != bp_hardware_breakpoint) || thread != -1) b->pspace = current_program_space; this code is only executed when creating a pending breakpoint, and sets the breakpoint::pspace member variable. The above code gained the 'thread != -1' clause with this commit: commit cc72b2a2da6d6372cbdb1d14639a5fce84e1a325 Date: Fri Dec 23 17:06:16 2011 +0000 Introduce gdb.FinishBreakpoint in Python While the type_wanted checks were added with this commit: commit f8eba3c61629b3c03ac1f33853eab4d8507adb9c Date: Tue Dec 6 18:54:43 2011 +0000 the "ambiguous linespec" series Before this breakpoint::pspace was set unconditionally. If we look at how breakpoint::pspace is used today, some breakpoint types specifically set this field, either in their constructors, or in a wrapper function that calls the constructor. So, the watchpoint type and its sub-class set this variable, as does the catchpoint type, and all it's sub-classes. However, code_breakpoint doesn't specifically set this field within its constructor, though some sub-classes of code_breakpoint (ada_catchpoint, exception_catchpoint, internal_breakpoint, and momentary_breakpoint) do set this field. When I examine all the places that breakpoint::pspace is used, I believe that in every place where it is expected that this field is set, the breakpoint type will be one that specifically sets this field. Next, I observe two problems with the existing code. First, the above code is only hit for pending breakpoints, there's no equivalent code for non-pending breakpoints. This opens up the possibility of GDB entering non-consistent states; if a breakpoint is first created pending and then later gets a location, the pspace field will be set, while if the breakpoint is immediately non-pending, then the pspace field will never be set. Second, if we look at how breakpoint::pspace is used in the function breakpoint_program_space_exit, we see that when a program space is removed, any breakpoint with breakpoint::pspace set to the removed program space, will be deleted. This makes sense, but does mean we need to ensure breakpoint::pspace is only set for breakpoints that apply to a single program space. So, if I create pending dprintf breakpoint (type bp_dprintf) then the breakpoint::pspace variable will be set even though the dprintf is not really tied to that one program space. As a result, when the matching program space is removed the dprintf is incorrectly removed. Also, if I create a thread specific breakpoint, then, thanks to the 'thread != -1' clause the wrong program space will be stored in breakpoint::pspace (the current program space is always used, which might not be the program space that corresponds to the selected thread), as a result, the thread specific breakpoint will be deleted when the matching program space is removed. If we look at commit cc72b2a2da6d which added the 'thread != -1' clause, we can see this change was entirely redundant, the breakpoint::pspace is also set in bpfinishpy_init after create_breakpoint has been called. As such, I think we can safely drop the 'thread != -1' clause. For the other problems, I'm proposing to be pretty aggressive - I'd like to drop the breakpoint::pspace assignment completely from create_breakpoint. Having looked at how this variable is used, I believe that it is already set elsewhere in all the cases that it is needed. Maybe this code was needed at one time, but I can't see how it's needed any more. There's tests to expose the issues I've spotted with this code, and there's no regressions in testing. --- gdb/breakpoint.c | 3 - gdb/breakpoint.h | 18 +- .../gdb.multi/pending-bp-del-inferior.c | 28 +++ .../gdb.multi/pending-bp-del-inferior.exp | 216 ++++++++++++++++++ 4 files changed, 259 insertions(+), 6 deletions(-) create mode 100644 gdb/testsuite/gdb.multi/pending-bp-del-inferior.c create mode 100644 gdb/testsuite/gdb.multi/pending-bp-del-inferior.exp diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c index 3d8eab826bd..6370c17c4e0 100644 --- a/gdb/breakpoint.c +++ b/gdb/breakpoint.c @@ -9208,9 +9208,6 @@ create_breakpoint (struct gdbarch *gdbarch, b->disposition = tempflag ? disp_del : disp_donttouch; b->condition_not_parsed = 1; b->enable_state = enabled ? bp_enabled : bp_disabled; - if ((type_wanted != bp_breakpoint - && type_wanted != bp_hardware_breakpoint) || thread != -1) - b->pspace = current_program_space; if (b->type == bp_dprintf) update_dprintf_command_list (b.get ()); diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h index baa54573e1a..b37208271e4 100644 --- a/gdb/breakpoint.h +++ b/gdb/breakpoint.h @@ -823,9 +823,21 @@ struct breakpoint : public intrusive_list_node equals this. */ struct frame_id frame_id = null_frame_id; - /* The program space used to set the breakpoint. This is only set - for breakpoints which are specific to a program space; for - non-thread-specific ordinary breakpoints this is NULL. */ + /* The program space used to set the breakpoint. This is only set for + breakpoints that are not type bp_breakpoint or bp_hardware_breakpoint. + For thread or inferior specific breakpoints, the breakpoints are + managed via the thread and inferior member variables. */ + + /* If not nullptr then this is the program space for which this + breakpoint was created. All watchpoint and catchpoint sub-types set + this field, but not all of the code_breakpoint sub-types do; + generally, user created breakpoint types don't set this field, though + things might be more consistent if they did. + + When this variable is nullptr then a breakpoint might be associated + with multiple program spaces, though you need to check the thread, + inferior and task variables to see if a breakpoint was created for a + specific thread, inferior, or Ada task respectively. */ program_space *pspace = NULL; /* The location specification we used to set the breakpoint. */ diff --git a/gdb/testsuite/gdb.multi/pending-bp-del-inferior.c b/gdb/testsuite/gdb.multi/pending-bp-del-inferior.c new file mode 100644 index 00000000000..51b6492085f --- /dev/null +++ b/gdb/testsuite/gdb.multi/pending-bp-del-inferior.c @@ -0,0 +1,28 @@ +/* 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 . */ + +int +foo () +{ + return 0; +} + +int +main () +{ + return foo (); +} diff --git a/gdb/testsuite/gdb.multi/pending-bp-del-inferior.exp b/gdb/testsuite/gdb.multi/pending-bp-del-inferior.exp new file mode 100644 index 00000000000..cb1f119ff94 --- /dev/null +++ b/gdb/testsuite/gdb.multi/pending-bp-del-inferior.exp @@ -0,0 +1,216 @@ +# 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 . + +# Setup two inferiors. Select one inferior and create a pending +# thread specific breakpoint in the other inferior. +# +# Delete the selected inferior (the one for which the thread specific +# breakpoint doesn't apply), and check that the breakpoint still exists. +# +# Repeat this process, but this time, create an inferior specific +# breakpoint. + +# The plain remote target can't do multiple inferiors. +require !use_gdb_stub + +standard_testfile + +if {[prepare_for_testing "failed to prepare" $testfile $srcfile]} { + return -1 +} + +# Setup for the tests. Create two inferiors, both running the global +# BINFILE, and proceed to main in both inferiors. Delete all +# breakpoints, and check that we do have two threads. +# +# Return true after a successful setup, otherwise, return false. +proc test_setup {} { + clean_restart $::binfile + + if {![runto_main]} { + return 0 + } + + gdb_test "add-inferior -exec ${::binfile}" "Added inferior 2.*" \ + "add inferior 2" + gdb_test "inferior 2" "Switching to inferior 2 .*" \ + "select inferior 2" + + if {![runto_main]} { + return 0 + } + + delete_breakpoints + + gdb_test "info threads" \ + [multi_line \ + " Id\\s+Target Id\\s+Frame\\s*" \ + " 1\\.1\\s+\[^\r\n\]+" \ + "\\* 2\\.1\\s+\[^\r\n\]+"] \ + "check we have the expected threads" + + return 1 +} + +# Assuming inferior 2 is already selected, kill the current inferior +# (inferior 2), selected inferior 1, and then remove inferior 2. +proc kill_and_remove_inferior_2 {} { + gdb_test "kill" "" "kill inferior 2" \ + "Kill the program being debugged.*y or n. $" "y" + + gdb_test "inferior 1" "Switching to inferior 1 .*" \ + "select inferior 1" + + gdb_test_no_output "remove-inferiors 2" +} + +# Setup two inferiors, then created a breakpoint. If BP_PENDING is +# true then the breakpoint will be pending, otherwise, the breakpoint +# will be non-pending. +# +# BP_TYPE is either 'thread' or 'inferior', and indicates if the +# created breakpoint should be thread or inferior specific. +# +# The breakpoint is created while inferior 2 is selected, and the +# thread/inferior restriction always identifies inferior 1. +# +# Then inferior 2 is killed and removed. +# +# Finally, check that the breakpoint still exists and correctly refers +# to inferior 1. +proc do_bp_test { bp_type bp_pending } { + if {![test_setup]} { + return + } + + if { $bp_pending } { + set bp_func "bar" + } else { + set bp_func "foo" + } + + if { $bp_type eq "thread" } { + set bp_restriction "thread 1.1" + } else { + set bp_restriction "inferior 1" + } + + gdb_breakpoint "$bp_func $bp_restriction" allow-pending + set bp_number [get_integer_valueof "\$bpnum" "INVALID" \ + "get b/p number for previous breakpoint"] + + if { $bp_restriction eq "thread 1.1" } { + set bp_after_restriction "thread 1" + } else { + set bp_after_restriction $bp_restriction + } + + if { $bp_pending } { + set bp_pattern_before \ + [multi_line \ + "$bp_number\\s+breakpoint\\s+keep\\s+y\\s+\\s+${bp_func}" \ + "\\s+stop only in [string_to_regexp $bp_restriction]"] + set bp_pattern_after \ + [multi_line \ + "$bp_number\\s+breakpoint\\s+keep\\s+y\\s+\\s+${bp_func}" \ + "\\s+stop only in [string_to_regexp $bp_after_restriction]"] + } else { + set bp_pattern_before \ + [multi_line \ + "$bp_number\\s+breakpoint\\s+keep\\s+y\\s+\\s*" \ + "\\s+stop only in [string_to_regexp $bp_restriction]" \ + "$bp_number\\.1\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+ inf 1" \ + "$bp_number\\.2\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+ inf 2"] + + set bp_pattern_after \ + [multi_line \ + "$bp_number\\s+breakpoint\\s+keep\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+" \ + "\\s+stop only in [string_to_regexp $bp_after_restriction]"] + } + + gdb_test "info breakpoints" $bp_pattern_before \ + "info breakpoints before inferior removal" + + kill_and_remove_inferior_2 + + gdb_test "info breakpoints" $bp_pattern_after \ + "info breakpoints after inferior removal" +} + +# Setup two inferiors, then created a dprintf. If BP_PENDING is +# true then the dprintf will be pending, otherwise, the dprintf +# will be non-pending. +# +# The dprintf is created while inferior 2. Then inferior 2 is killed +# and removed. +# +# Finally, check that the dprintf still exists. +proc do_dprintf_test { bp_pending } { + if {![test_setup]} { + return + } + + if { $bp_pending } { + set bp_func "bar" + + gdb_test "dprintf $bp_func,\"in $bp_func\"" ".*" \ + "create dprintf breakpoint" \ + "Make dprintf pending on future shared library load\\? \\(y or .n.\\) $" "y" + } else { + set bp_func "foo" + + gdb_test "dprintf $bp_func,\"in $bp_func\"" ".*" \ + "create dprintf breakpoint" + } + + set bp_number [get_integer_valueof "\$bpnum" "INVALID" \ + "get b/p number for previous breakpoint"] + + if { $bp_pending } { + set bp_pattern_before \ + [multi_line \ + "$bp_number\\s+dprintf\\s+keep\\s+y\\s+\\s+${bp_func}" \ + "\\s+printf \"in $bp_func\""] + set bp_pattern_after $bp_pattern_before + } else { + set bp_pattern_before \ + [multi_line \ + "$bp_number\\s+dprintf\\s+keep\\s+y\\s+\\s*" \ + "\\s+printf \"in $bp_func\"" \ + "$bp_number\\.1\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+ inf 1" \ + "$bp_number\\.2\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+ inf 2"] + + set bp_pattern_after \ + [multi_line \ + "$bp_number\\s+dprintf\\s+keep\\s+y\\s+$::hex in $bp_func at \[^\r\n\]+" \ + "\\s+printf \"in $bp_func\""] + } + + gdb_test "info breakpoints" $bp_pattern_before \ + "info breakpoints before inferior removal" + + kill_and_remove_inferior_2 + + gdb_test "info breakpoints" $bp_pattern_after \ + "info breakpoints after inferior removal" +} + +foreach_with_prefix bp_pending { true false } { + foreach_with_prefix bp_type { thread inferior } { + do_bp_test $bp_type $bp_pending + } + + do_dprintf_test $bp_pending +}