gdb/tui: use maybe_update for source centring in an extra case

I noticed that, with recent versions of GDB, when the TUI is enabled
before the inferior is started, the source code display is not as
helpful as it used to be.  Here's a simple test program being
displayed using GDB 15.2, at this point the inferior has not started,
all I've done is 'tui enable':

  ┌─hello.c────────────────────────────────────────────────┐
  │     10   return 0;                                     │
  │     11 }                                               │
  │     12                                                 │
  │     13 /* The main function.  */                       │
  │     14                                                 │
  │     15 int                                             │
  │     16 main ()                                         │
  │     17 {                                               │
  │     18   printf ("Hello World\n");                     │
  │     19   call_me ( 0, 1, 2, 3, 4, 5, 6, 7 );           │
  │     20   return 0;                                     │
  │     21 }                                               │
  │                                                        │
  │                                                        │
  └────────────────────────────────────────────────────────┘

Compare this to GDB 16.2:

  ┌─hello.c────────────────────────────────────────────────┐
  │       17 {                                             │
  │       18   printf ("Hello World\n");                   │
  │       19   call_me ( 0, 1, 2, 3, 4, 5, 6, 7 );         │
  │       20   return 0;                                   │
  │       21 }                                             │
  │                                                        │
  │                                                        │
  │                                                        │
  │                                                        │
  │                                                        │
  │                                                        │
  │                                                        │
  │                                                        │
  │                                                        │
  └────────────────────────────────────────────────────────┘

I think the new layout is not as good because it is missing the
context of the function name.  The new behaviour started with the
commit:

  commit 49e607f511c1fab82a0116990a72d1915c74bb4a
  Author: Stephan Rohr <stephan.rohr@intel.com>
  Date:   Sat Aug 3 02:07:42 2024 -0700

      gdb: adjust the default place of 'list' to main's prologue

I don't think the new behaviour is really a problem with that commit,
rather, when using 'tui enable' before the inferior has started GDB
ends up calling tui_source_window_base::rerender(), and then passes
through the code path which calls update_source_window_with_addr().

When using 'tui enable' after the inferior has started, GDB again
calls tui_source_window_base::rerender(), but this time has a frame,
and so takes the second code path, which centres the selected source
line, and then calls update_source_window.

The point is that the update_source_window_with_addr() path doesn't
include the logic to centre the source line.

Before the above commit this was fine as GDB's default location would
be prior to main, and so we got the "good" TUI output.  After the
above commit the default location is now main's prologue, and without
the centring logic, the first line shown is main's prologue.

I propose fixing this by having update_source_window_with_addr() call
maybe_update().  This will first check if the requested line is
already visible, and if not, show the requested line with centring
applied.

After this commit, the 'tui enable' state is now:

  ┌─hello.c─────────────────────────────────────────────────────┐
  │       11 }                                                  │
  │       12                                                    │
  │       13 /* The main function.  */                          │
  │       14                                                    │
  │       15 int                                                │
  │       16 main ()                                            │
  │       17 {                                                  │
  │       18   printf ("Hello World\n");                        │
  │       19   call_me ( 0, 1, 2, 3, 4, 5, 6, 7 );              │
  │       20   return 0;                                        │
  │       21 }                                                  │
  │                                                             │
  │                                                             │
  │                                                             │
  └─────────────────────────────────────────────────────────────┘

It's not identical to the old behaviour, but that was never the
objective, we do however, see the context around main's prologue,
which will usually be enough to see the function name and return type,
which I think is useful.

Approved-By: Tom Tromey <tom@tromey.com>

0 files changed, 0 insertions, 0 deletions