From: Bruno Larsen <blarsen@redhat.com>
To: Carl Love <cel@us.ibm.com>, Simon Marchi <simark@simark.ca>,
Tom de Vries <tdevries@suse.de>,
Ulrich Weigand <Ulrich.Weigand@de.ibm.com>,
"gdb-patches@sourceware.org" <gdb-patches@sourceware.org>,
"pedro@palves.net" <pedro@palves.net>
Subject: Re: [PATCH 2/2 ] PowerPC: fix for gdb.reverse/finish-precsave.exp and gdb.reverse/finish-reverse.exp
Date: Wed, 2 Aug 2023 11:29:59 +0200 [thread overview]
Message-ID: <bc23974c-7f3e-7b3a-272e-fb111447206f@redhat.com> (raw)
In-Reply-To: <a7dd338fe741b19f90e95e0a81ebab10abc7d150.camel@us.ibm.com>
On 01/08/2023 00:59, Carl Love wrote:
> Bruno:
>
> On Fri, 2023-07-21 at 09:24 +0200, Bruno Larsen wrote:
>>> I think what Bruno is again asking is to have
>>> control.step_range_start
>>> set to the real start range initially, i.e. what Simon asked
>>> about. I
>>> think to do that, we would need to make significant changes to how
>>> reverse execution works to allow us to make that change. It didn't
>>> appear to be a straight forward fix to me. I may be wrong. Maybe
>>> someone sees a good way to make that work that I am missing. So it
>>> looks like this patch fixes most issues but not all of the problems
>>> with reverse-step and reverse-next. It might be good to try and
>>> fix
>>> this additional scenario in a separate patch, not sure???
>> I just tested with the newest version of the patch relating to
>> reverse
>> stepping over contiguous lines, but that didn't make a difference.
>> GCC
>> continued broken. I think the problem is that GCC doesn't have
>> contiguous ranges, it has a single range that doesn't contain the PC
>>
>> My (probably naive) thinking is to set step_range_end to the starting
>> PC
>> of the following line, and step_range_start to be the real start of
>> the
>> current line at the moment the command is parsed. This sounds like
>> it
>> would solve the GCC problem, but I assume I'm missing something.
>> Unfortunately, I don't have the time to test this theory myself, but
>> I'll happily test any patches you submit :). If you want to repeat
>> my
>> test, I want the behavior of gdb.reverse/finish-reverse-next from gcc
>> to
>> match clang's (on x86 machines), that is, if you reverse finish from
>> function1, a single "rn" command would land you on the b=5 line.
> So, I took the example of the error from your previous patch where you
> demonstrated the scenario where you have stopped at the call to the
> function, then do the reverse-next which stops at the beginning of the
> same line and put it into a new test case for discussion and for
> debugging the issue. Nice to have a simple example of the issue. The
> new test is bruno_7_20_2023.exp. So, in this test, when we are stopped
> at the call, as you showed on Intel
>
> (gdb) maint info line-table
>> (snip)
>> 15 81 0x0000000000401185 0x0000000000401185 Y
>> 16 83 0x000000000040118c 0x000000000040118c Y
>> 17 86 0x000000000040119b 0x000000000040119b Y
>> (gdb) disas /s
>> Dump of assembler code for function main:
>> (snip)
>> 83 function1 (a, b); // CALL VIA LEP
>> 0x000000000040118c <+37>: mov -0x10(%rbp),%edx
>> 0x000000000040118f <+40>: mov -0xc(%rbp),%eax
>> 0x0000000000401192 <+43>: mov %edx,%esi
>> 0x0000000000401194 <+45>: mov %eax,%edi
>> => 0x0000000000401196 <+47>: call 0x40112c <function1>
>>
>> We can see that we have stopped at the right instruction, but it
>> isn't
>> mapped to any line number directly. If we reverse-next from there:
> the tp->control.step_range_start is set to 0x40118c in function
> prepare_one_step() in gdb/infcmd.c. The PC in your case is at
> 0x401196. Of course both of the addresses are in the same line. We
> are executing backwards so we need step_range_start to be set to a
> value in the previous line. In general, we have no idea what the
> previous line was as we may have arrived on this line via a jump or
> branch in theory. Also, note, when setting the range we need to have
> the PC in the range or GDB will give us an assert error.
>
> So really the issue is that we want the step_range_start to be in the
> line where we came from. So, if we see the line number for PC and
> step_range_start are the same, we can set step_range_start to one less
> then the address of the beginning of the current line when we parse the
> instruction and setup the stepping range. The goal is to have GDB stop
> in the previous line and not at the beginning of the line and thus
> match the behavior of gdb on clang.
>
> I implemented the check and adjustment for step_range_start as just
> described and tested it with your example, bruno_7_20_2023.exp and it
> does seem to work as desired.
>
> The existing testcases expect to have to do two reverse step/next
> instructions to reach the previous line. So, we need to fix the
> existing tests gdb.reverse/finish-reverse-next.exp and gdb.mi/mi-
> reverse.exp to remove the extra reverse step/next command.
>
> Anyway, I put the gdb code fix, the bruno_7_20_2023.exp and test fixes
> into the patch below for discussion purposes. If everyone is happy
> with the gdb change and test changes (we can drop the Bruno test) I can
> merge these changes into the patch. Hopefully keeping these changes in
> a separate patch for the moment will make it easier to see what is
> being changed.
Hi Carl!
Thanks for the thorough explanation and test. You did understood what I
meant perfectly :)
This is a little besides the point, but I don't see any other patches
that touch this area and haven't been committed yet. Am I missing
something obvious?
Regardless, I feel like this one change can propagate enough that it
should be its own commit anyway.
>
> If you were to apply the following patch on top of the currently
> proposed patch, does gdb then execute as you expect on your system? I
> have tested the change on IBM Power 10. It would be good to make sure
> it works on your X86 system as well. I also ran the full gdb
> regression tests on Power 10 with no additional regression failures.
> Thanks for looking at the patch, proposed fix and the additional
> testing.
The patch didn't apply on current master, but I added the changes
manually and tested it. It does fix the issue, and adds no regressions.
I feel like it could be worth sending an official version this patch as
a new thread, instead of a reply to this one, to get people who might
not be interested in reverse debugging but may have thoughts on this
patch, but maybe wait a bit to see if someone in here says anything :)
--
Cheers,
Bruno
>
> Carl
> ---------------------------------------------------------------
> [PATCH 2/2] finish-reverse-next new test case from bruno.
>
> GDB fix for Bruno test, updated other tests for the gdb fix.
> ---
> gdb/infcmd.c | 9 ++
> gdb/testsuite/gdb.mi/mi-reverse.exp | 6 +-
> gdb/testsuite/gdb.reverse/bruno_7_20_2023.exp | 85 +++++++++++++++++++
> .../gdb.reverse/finish-reverse-next.exp | 44 +++++++---
> 4 files changed, 133 insertions(+), 11 deletions(-)
> create mode 100644 gdb/testsuite/gdb.reverse/bruno_7_20_2023.exp
>
> diff --git a/gdb/infcmd.c b/gdb/infcmd.c
> index b8134665f3f..c09b3edad3d 100644
> --- a/gdb/infcmd.c
> +++ b/gdb/infcmd.c
> @@ -981,6 +981,15 @@ prepare_one_step (thread_info *tp, struct step_command_fsm *sm)
> find_pc_line_pc_range (pc,
> &tp->control.step_range_start,
> &tp->control.step_range_end);
> + symtab_and_line sal = find_pc_line (pc, 0);
> + symtab_and_line sal_start
> + = find_pc_line (tp->control.step_range_start, 0);
> +
> + if (sal.line == sal_start.line)
> + /* The step_range_start address is in the same line. We want to
> + stop in the previous line so move step_range_start one
> + instruction earlier. */
> + tp->control.step_range_start--;
>
> /* There's a problem in gcc (PR gcc/98780) that causes missing line
> table entries, which results in a too large stepping range.
> diff --git a/gdb/testsuite/gdb.mi/mi-reverse.exp b/gdb/testsuite/gdb.mi/mi-reverse.exp
> index baa53a495d7..997309cfb71 100644
> --- a/gdb/testsuite/gdb.mi/mi-reverse.exp
> +++ b/gdb/testsuite/gdb.mi/mi-reverse.exp
> @@ -99,8 +99,12 @@ proc test_controlled_execution_reverse {} {
> # It takes two steps to get back to the previous line,
> # as the first step moves us to the start of the current line,
> # and the one after that moves back to the previous line.
> +## I BELIEVE Bruno is arguing this part of the test is wrong. When we are
> +## stopped at the call, which is the last instruction in the line, the
> +## reverse next should take us directly to the previous line, not stop at
> +## the first instruction in the same line.
>
> - mi_execute_to "exec-next --reverse 2" \
> + mi_execute_to "exec-next --reverse" \
> "end-stepping-range" "main" "" \
> "basics.c" $line_main_hello "" \
> "reverse next to get over the call to do_nothing"
> diff --git a/gdb/testsuite/gdb.reverse/bruno_7_20_2023.exp b/gdb/testsuite/gdb.reverse/bruno_7_20_2023.exp
> new file mode 100644
> index 00000000000..0f19a959043
> --- /dev/null
> +++ b/gdb/testsuite/gdb.reverse/bruno_7_20_2023.exp
> @@ -0,0 +1,85 @@
> +# Copyright 2008-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 <http://www.gnu.org/licenses/>. */
> +
> +# This file is part of the GDB testsuite. It tests reverse stepping.
> +# Lots of code borrowed from "step-test.exp".
> +
> +# The reverse finish command should return from a function and stop on
> +# the first instruction of the source line where the function call is made.
> +# Specifically, the behavior should match doing a reverse next from the
> +# first instruction in the function. GDB should only take one reverse step
> +# or next statement to reach the previous source code line.
> +
> +# This testcase verifies the reverse-finish command stops at the first
> +# instruction in the source code line where the function was called. There
> +# are two scenarios that must be checked:
> +# 1) gdb is at the entry point instruction for the function
> +# 2) gdb is in the body of the function.
> +
> +# This test verifies the fix for gdb bugzilla:
> +# https://sourceware.org/bugzilla/show_bug.cgi?id=29927
> +
> +# PowerPC supports two entry points to a function. The normal entry point
> +# is called the local entry point (LEP). The alternate entry point is called
> +# the global entry point (GEP). A function call via a function pointer
> +# will entry via the GEP. A normal function call will enter via the LEP.
> +#
> +# This test has been expanded to include tests to verify the reverse-finish
> +# command works properly if the function is called via the GEP. The original
> +# test only verified the reverse-finish command for a normal call that used
> +# the LEP.
> +
> +if ![supports_reverse] {
> + return
> +}
> +
> +standard_testfile finish-reverse-next.c
> +
> +if { [prepare_for_testing "failed to prepare" $testfile $srcfile] } {
> + return -1
> +}
> +
> +runto_main
> +set target_remote [gdb_is_target_remote]
> +
> +if [supports_process_record] {
> + # Activate process record/replay.
> + gdb_test_no_output "record" "turn on process record for test1"
> +}
> +
> +
> +# until 83
> +# Set breakpoint at call to function1 in main.
> +set bp_LEP_test [gdb_get_line_number "CALL VIA LEP" $srcfile]
> +gdb_breakpoint $srcfile:$bp_LEP_test temporary
> +
> +# Continue to break point at function1 call in main.
> +gdb_continue_to_breakpoint \
> + "stopped at function1 entry point instruction to stepi into function" \
> + ".*$srcfile:$bp_LEP_test\r\n.*"
> +
> +gdb_test "next" ".*a = 10;.*" \
> + "next from function body function1 LEP to a = 10;"
> +
> +gdb_test "reverse-step" ".*70.*}.*" \
> + "reverse step from a = 10, stops at last inst in function1 call"
> +
> +gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \
> + "reverse-finish should stop at last inst in line for function1"
> +
> +gdb_test "reverse-next" ".*b = 5;.*" \
> + "reverse-finish should stop at b = 5, not first inst in line for function1"
> +
> +
> diff --git a/gdb/testsuite/gdb.reverse/finish-reverse-next.exp b/gdb/testsuite/gdb.reverse/finish-reverse-next.exp
> index 1f53b649a7d..921d0051233 100644
> --- a/gdb/testsuite/gdb.reverse/finish-reverse-next.exp
> +++ b/gdb/testsuite/gdb.reverse/finish-reverse-next.exp
> @@ -80,10 +80,15 @@ repeat_cmd_until "stepi" "CALL VIA LEP" "{" "stepi into function1 call" "100"
> # instruction should then stop at the first instruction in the same source
> # code line. Another revers-next instruction stops at the previous source
> # code line.
> +
> +## I BELIEVE Bruno is arguing this part of the test is wrong. When we are
> +## stopped at the call, which is the last instruction in the line, the
> +## reverse next should take us directly to the previous line, not stop at
> +## the first instruction in the same line.
> gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \
> "reverse-finish function1 LEP call from LEP "
> -gdb_test "reverse-next" ".*function1 \\(a, b\\); // CALL VIA LEP" \
> - "reverse next 1 LEP entry point function call from LEP"
> +##gdb_test "reverse-next" ".*function1 \\(a, b\\); // CALL VIA LEP" \
> +## "reverse next 1 LEP entry point function call from LEP"
> gdb_test "reverse-next" ".*b = 5;.*" "reverse next 2, at b = 5, call from LEP"
>
>
> @@ -113,10 +118,14 @@ gdb_test "step" ".*int ret = 0;.*" "step test 1"
> # instruction should then stop at the first instruction in the same source
> # code line. Another revers-next instruction stops at the previous source
> # code line.
> +## I BELIEVE Bruno is arguing this part of the test is wrong. When we are
> +## stopped at the call, which is the last instruction in the line, the
> +## reverse next should take us directly to the previous line, not stop at
> +## the first instruction in the same line.
> gdb_test "reverse-finish" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \
> "reverse-finish function1 LEP call from function body"
> -gdb_test "reverse-next" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \
> - "reverse next 1 LEP from function body"
> +## gdb_test "reverse-next" ".*function1 \\(a, b\\); // CALL VIA LEP.*" \
> +## "reverse next 1 LEP from function body"
> gdb_test "reverse-next" ".*b = 5;.*" \
> "reverse next 2 at b = 5, from function body"
>
> @@ -148,10 +157,15 @@ repeat_cmd_until "stepi" "CALL VIA GEP" "{" "stepi into funp call"
> # instruction should then stop at the first instruction in the same source
> # code line. Another revers-next instruction stops at the previous source
> # code line.
> +## I BELIEVE Bruno is arguing this part of the test is wrong. When we are
> +## stopped at the call, which is the last instruction in the line, the
> +## reverse next should take us directly to the previous line, not stop at
> +## the first instruction in the same line.
> +
> gdb_test "reverse-finish" ".*funp \\(a, b\\);.*" \
> "function1 GEP call call from GEP"
> -gdb_test "reverse-next" ".*funp \\(a, b\\);.*" \
> - "reverse next 1 GEP entry point function call from GEP"
> +## gdb_test "reverse-next" ".*funp \\(a, b\\);.*" \
> +## "reverse next 1 GEP entry point function call from GEP"
> gdb_test "reverse-next" ".*b = 50;.*" "reverse next 2 at b = 50, call from GEP"
>
> gdb_test "reverse-continue" ".*" "setup for test 4"
> @@ -184,10 +198,15 @@ gdb_test "stepi" "{" "stepi to between GEP and LEP"
> # instruction should then stop at the first instruction in the same source
> # code line. Another revers-next instruction stops at the previous source
> # code line.
> +## I BELIEVE Bruno is arguing this part of the test is wrong. When we are
> +## stopped at the call, which is the last instruction in the line, the
> +## reverse next should take us directly to the previous line, not stop at
> +## the first instruction in the same line.
> +
> gdb_test "reverse-finish" ".*funp \\(a, b\\);.*" \
> "function1 GEP call call from GEP again"
> -gdb_test "reverse-next" ".*funp \\(a, b\\);.*" \
> - "reverse next 1 GEP entry point function call from GEP again"
> +##gdb_test "reverse-next" ".*funp \\(a, b\\);.*" \
> +## "reverse next 1 GEP entry point function call from GEP again"
> gdb_test "reverse-next" ".*b = 50;.*" \
> "reverse next 2 at b = 50, call from GEP again"
>
> @@ -216,9 +235,14 @@ gdb_test "step" ".*int ret = 0;.*" "step test 2"
> # instruction should then stop at the first instruction in the same source
> # code line. Another revers-next instruction stops at the previous source
> # code line.
> +## I BELIEVE Bruno is arguing this part of the test is wrong. When we are
> +## stopped at the call, which is the last instruction in the line, the
> +## reverse next should take us directly to the previous line, not stop at
> +## the first instruction in the same line.
> +
> gdb_test "reverse-finish" ".*funp \\(a, b\\);.*" \
> "reverse-finish function1 GEP call, from function body "
> -gdb_test "reverse-next" ".*funp \\(a, b\\);.*" \
> - "reverse next 1 GEP call from function body"
> +## gdb_test "reverse-next" ".*funp \\(a, b\\);.*" \
> +## "reverse next 1 GEP call from function body"
> gdb_test "reverse-next" ".*b = 50;.*" \
> "reverse next 2 at b = 50 from function body"
next prev parent reply other threads:[~2023-08-02 9:30 UTC|newest]
Thread overview: 105+ messages / expand[flat|nested] mbox.gz Atom feed top
[not found] <f594ec0070a6c585e83a6d6c8b29481a86778c0f.camel@us.ibm.com>
[not found] ` <bc6bb459f153c0c5850d4a3e5d80bbf957ec36cc.camel@de.ibm.com>
[not found] ` <8bce850fa1e03e798506dc170d9b57f52034a18a.camel@us.ibm.com>
[not found] ` <cb5875db4e1ac60475877c685e5f172770314523.camel@de.ibm.com>
[not found] ` <adeeeae47c4ca79b32d79aea632ff8b2a24dd93d.camel@us.ibm.com>
[not found] ` <86c5e9c47945894f21b1d8bf6089c730a9f0e1a5.camel@de.ibm.com>
[not found] ` <b1d7ea600d6bb7af487968d938566fae9d5e1745.camel@us.ibm.com>
[not found] ` <5f9047b9582403561d7cce998cab9184167366a1.camel@de.ibm.com>
[not found] ` <e7c8093c350ad475277154014a4f0bb9b472b7af.camel@us.ibm.com>
[not found] ` <f8d6379aff7af076d9edcee7d2981d052b2161ee.camel@de.ibm.com>
[not found] ` <5b50668cbe882c57b8c0e9dcf5be0a253713c4c6.camel@us.ibm.com>
[not found] ` <51c4bfc82ac72e475e10577dc60e4d75fa48767e.camel@de.ibm.com>
[not found] ` <3ea97a8aa9cccb39299adde682f92055d1986ab3.camel@us.ibm.com>
[not found] ` <f5ea8da12631f2496ba0e2263e65a0adc7ac56ca.camel@de.ibm.com>
[not found] ` <53878e37c6e57de1d04d9c9960c5d0a74324ee6e.camel@us.ibm.com>
[not found] ` <a5300b64533fdc753c1d50fa0e6efc21b5457547.camel@de.ibm.com>
[not found] ` <50474aa92ba82eff05cdc8f49001eae56be29670.camel@us.ibm.com>
[not found] ` <f3ef4486c4ba051024602928acdfe5ddf6942b82.camel@de.ibm.com>
[not found] ` <dae6c9790b23a90d5f1494f5b6798346444f257e.camel@us.ibm.com>
[not found] ` <89331c26795e3f7743e1e068dce43b3c2dd53008.camel@us.ibm.com>
[not found] ` <c10a008e441666e4edb0916842d8eefe83f5b2f9.camel@de.ibm.com>
[not found] ` <071f24ecf9b3a2bbbe8fee7db77492eb55c5f3ff.camel@us.ibm.com>
[not found] ` <1d9b21914354bef6a290ac30673741e722e11757.camel@de.ibm.com>
2023-01-11 18:27 ` [PATCH 0/2] " Carl Love
2023-01-11 18:27 ` [PATCH 1/2] " Carl Love
2023-01-12 16:56 ` Tom de Vries
2023-01-12 18:54 ` Carl Love
2023-01-13 13:33 ` Bruno Larsen
2023-01-13 16:43 ` Carl Love
2023-01-13 17:04 ` Bruno Larsen
2023-01-13 19:10 ` Carl Love
2023-01-14 18:08 ` Carl Love
2023-01-16 12:31 ` Bruno Larsen
2023-01-16 16:37 ` [PATCH 0/2 version 2] " Carl Love
2023-01-16 16:37 ` [PATCH 1/2 " Carl Love
2023-01-17 12:35 ` Bruno Larsen
2023-01-20 0:03 ` [PATCH 1/2 version 3] " Carl Love
2023-01-23 19:17 ` Pedro Alves
2023-01-23 21:13 ` Carl Love
2023-01-24 14:08 ` Pedro Alves
2023-01-24 14:23 ` Bruno Larsen
2023-01-24 15:06 ` Pedro Alves
2023-01-24 16:04 ` Bruno Larsen
2023-01-24 19:12 ` Pedro Alves
2023-01-25 9:49 ` Bruno Larsen
2023-01-25 14:11 ` Ulrich Weigand
2023-01-25 16:42 ` Pedro Alves
2023-01-25 17:13 ` Ulrich Weigand
2023-01-25 17:24 ` Pedro Alves
2023-01-25 19:38 ` Carl Love
2023-01-24 15:51 ` Carl Love
2023-01-24 18:37 ` Pedro Alves
2023-01-24 18:25 ` Carl Love
2023-01-24 19:21 ` Pedro Alves
2023-01-24 19:26 ` Pedro Alves
2023-01-31 0:17 ` Reverse-next bug test case Carl Love
2023-02-01 14:37 ` Pedro Alves
2023-02-01 18:40 ` Carl Love
2023-01-24 15:53 ` [PATCH 1/2 version 3] fix for gdb.reverse/finish-precsave.exp and gdb.reverse/finish-reverse.exp Tom de Vries
2023-01-24 18:48 ` Pedro Alves
2023-01-16 16:37 ` [PATCH 2/2 version 2] " Carl Love
2023-01-17 14:29 ` Bruno Larsen
2023-01-17 16:36 ` Carl Love
2023-01-17 16:55 ` Tom de Vries
2023-01-17 17:03 ` Carl Love
2023-01-17 17:14 ` Tom de Vries
2023-01-17 19:31 ` Carl Love
2023-01-18 10:55 ` Tom de Vries
2023-01-18 16:16 ` Carl Love
2023-01-18 22:26 ` Carl Love
2023-01-19 8:04 ` Bruno Larsen
2023-01-19 16:56 ` Carl Love
2023-01-19 23:57 ` Carl Love
2023-01-20 20:04 ` Carl Love
2023-01-23 16:42 ` [PATCH 1/2 version 3] " Carl Love
2023-01-23 16:42 ` [PATCH 2/2 " Carl Love
2023-02-10 20:55 ` [PATCH ] PowerPC: " Carl Love
2023-02-17 12:24 ` Ulrich Weigand
2023-02-20 16:34 ` Carl Love
2023-02-20 16:48 ` Bruno Larsen
2023-02-20 20:24 ` Carl Love
2023-02-27 16:09 ` [PING] " Carl Love
2023-02-28 13:39 ` Bruno Larsen
2023-02-28 16:19 ` Carl Love
2023-03-01 13:43 ` Tom de Vries
2023-03-01 16:26 ` Carl Love
2023-03-01 14:03 ` Tom de Vries
2023-03-01 16:43 ` Carl Love
2023-03-01 14:34 ` Tom de Vries
2023-03-01 20:39 ` Carl Love
2023-03-01 20:59 ` [PATCH 0/2 " Carl Love
2023-03-01 20:59 ` [PATCH 1/2] " Carl Love
2023-03-03 11:56 ` Bruno Larsen
2023-03-08 16:19 ` [PING] " Carl Love
2023-03-09 16:09 ` Carl Love
2023-03-09 19:03 ` Tom Tromey
2023-03-09 21:42 ` Carl Love
2023-03-09 21:54 ` [PATCH 1/2 ver 2] " Carl Love
2023-03-10 3:53 ` Tom Tromey
2023-03-01 20:59 ` [PATCH 2/2 ] " Carl Love
2023-03-08 16:19 ` [PING] " Carl Love
2023-03-09 16:09 ` Carl Love
2023-03-13 14:16 ` Ulrich Weigand
2023-03-13 17:31 ` Carl Love
2023-03-13 17:38 ` [PATCH 2/2 ver2] " Carl Love
2023-03-17 17:19 ` Ulrich Weigand
2023-03-17 23:05 ` Tom de Vries
2023-03-20 15:04 ` Carl Love
2023-03-20 23:21 ` Carl Love
2023-03-21 3:17 ` Carl Love
2023-03-21 6:52 ` Ulrich Weigand
2023-03-24 17:23 ` [PATCH 2/2 ] " Simon Marchi
2023-03-24 22:16 ` Carl Love
2023-03-25 12:39 ` Simon Marchi
2023-03-27 23:59 ` Carl Love
2023-03-28 1:19 ` Simon Marchi
2023-03-28 15:17 ` Carl Love
2023-03-28 15:38 ` Simon Marchi
2023-07-20 12:01 ` Bruno Larsen
2023-07-20 14:45 ` Carl Love
2023-07-21 7:24 ` Bruno Larsen
2023-07-31 22:59 ` Carl Love
2023-08-02 9:29 ` Bruno Larsen [this message]
2023-08-02 15:11 ` Carl Love
2023-01-13 15:42 ` [PATCH 1/2] " Bruno Larsen
2023-01-11 18:27 ` [PATCH 2/2] " Carl Love
2023-01-13 15:55 ` Bruno Larsen
2023-01-14 18:08 ` Carl Love
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=bc23974c-7f3e-7b3a-272e-fb111447206f@redhat.com \
--to=blarsen@redhat.com \
--cc=Ulrich.Weigand@de.ibm.com \
--cc=cel@us.ibm.com \
--cc=gdb-patches@sourceware.org \
--cc=pedro@palves.net \
--cc=simark@simark.ca \
--cc=tdevries@suse.de \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).