gdb/tui/tui-stack.c

   1 /* TUI display locator.
   2
   3    Copyright (C) 1998-2019 Free Software Foundation, Inc.
   4
   5    Contributed by Hewlett-Packard Company.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "breakpoint.h"
  25 #include "frame.h"
  26 #include "command.h"
  27 #include "inferior.h"
  28 #include "target.h"
  29 #include "top.h"
  30 #include "gdb-demangle.h"
  31 #include "source.h"
  32 #include "tui/tui.h"
  33 #include "tui/tui-data.h"
  34 #include "tui/tui-stack.h"
  35 #include "tui/tui-wingeneral.h"
  36 #include "tui/tui-source.h"
  37 #include "tui/tui-winsource.h"
  38 #include "tui/tui-file.h"
  39
  40 #include "gdb_curses.h"
  41
  42 #define PROC_PREFIX             "In: "
  43 #define LINE_PREFIX             "L"
  44 #define PC_PREFIX               "PC: "
  45
  46 /* Minimum/Maximum length of some fields displayed in the TUI status
  47    line.  */
  48 #define MIN_LINE_WIDTH     4    /* Use at least 4 digits for line
  49                                    numbers.  */
  50 #define MIN_PROC_WIDTH    12
  51 #define MAX_TARGET_WIDTH  10
  52 #define MAX_PID_WIDTH     19
  53
  54 static struct tui_locator_window _locator;
  55
  56 \f
  57
  58 /* Accessor for the locator win info.  Answers a pointer to the static
  59    locator win info struct.  */
  60 struct tui_locator_window *
  61 tui_locator_win_info_ptr (void)
  62 {
  63   return &_locator;
  64 }
  65
  66 std::string
  67 tui_locator_window::make_status_line () const
  68 {
  69   char line_buf[50];
  70   int status_size;
  71   int proc_width;
  72   const char *pid_name;
  73   int target_width;
  74   int pid_width;
  75   int line_width;
  76
  77   std::string pid_name_holder;
  78   if (inferior_ptid == null_ptid)
  79     pid_name = "No process";
  80   else
  81     {
  82       pid_name_holder = target_pid_to_str (inferior_ptid);
  83       pid_name = pid_name_holder.c_str ();
  84     }
  85
  86   target_width = strlen (target_shortname);
  87   if (target_width > MAX_TARGET_WIDTH)
  88     target_width = MAX_TARGET_WIDTH;
  89
  90   pid_width = strlen (pid_name);
  91   if (pid_width > MAX_PID_WIDTH)
  92     pid_width = MAX_PID_WIDTH;
  93
  94   status_size = width;
  95
  96   /* Translate line number and obtain its size.  */
  97   if (line_no > 0)
  98     xsnprintf (line_buf, sizeof (line_buf), "%d", line_no);
  99   else
 100     strcpy (line_buf, "??");
 101   line_width = strlen (line_buf);
 102   if (line_width < MIN_LINE_WIDTH)
 103     line_width = MIN_LINE_WIDTH;
 104
 105   /* Translate PC address.  */
 106   std::string pc_out (gdbarch
 107                       ? paddress (gdbarch, addr)
 108                       : "??");
 109   const char *pc_buf = pc_out.c_str ();
 110   int pc_width = pc_out.size ();
 111
 112   /* First determine the amount of proc name width we have available.
 113      The +1 are for a space separator between fields.
 114      The -1 are to take into account the \0 counted by sizeof.  */
 115   proc_width = (status_size
 116                 - (target_width + 1)
 117                 - (pid_width + 1)
 118                 - (sizeof (PROC_PREFIX) - 1 + 1)
 119                 - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
 120                 - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
 121                 - (tui_current_key_mode == TUI_SINGLE_KEY_MODE
 122                    ? (sizeof (SINGLE_KEY) - 1 + 1)
 123                    : 0));
 124
 125   /* If there is no room to print the function name, try by removing
 126      some fields.  */
 127   if (proc_width < MIN_PROC_WIDTH)
 128     {
 129       proc_width += target_width + 1;
 130       target_width = 0;
 131       if (proc_width < MIN_PROC_WIDTH)
 132         {
 133           proc_width += pid_width + 1;
 134           pid_width = 0;
 135           if (proc_width <= MIN_PROC_WIDTH)
 136             {
 137               proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
 138               pc_width = 0;
 139               if (proc_width < 0)
 140                 {
 141                   proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
 142                   line_width = 0;
 143                   if (proc_width < 0)
 144                     proc_width = 0;
 145                 }
 146             }
 147         }
 148     }
 149
 150   /* Now create the locator line from the string version of the
 151      elements.  */
 152   string_file string;
 153
 154   if (target_width > 0)
 155     string.printf ("%*.*s ", -target_width, target_width, target_shortname);
 156   if (pid_width > 0)
 157     string.printf ("%*.*s ", -pid_width, pid_width, pid_name);
 158
 159   /* Show whether we are in SingleKey mode.  */
 160   if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
 161     {
 162       string.puts (SINGLE_KEY);
 163       string.puts (" ");
 164     }
 165
 166   /* Procedure/class name.  */
 167   if (proc_width > 0)
 168     {
 169       if (proc_name.size () > proc_width)
 170         string.printf ("%s%*.*s* ", PROC_PREFIX,
 171                        1 - proc_width, proc_width - 1, proc_name.c_str ());
 172       else
 173         string.printf ("%s%*.*s ", PROC_PREFIX,
 174                        -proc_width, proc_width, proc_name.c_str ());
 175     }
 176
 177   if (line_width > 0)
 178     string.printf ("%s%*.*s ", LINE_PREFIX,
 179                    -line_width, line_width, line_buf);
 180   if (pc_width > 0)
 181     {
 182       string.puts (PC_PREFIX);
 183       string.puts (pc_buf);
 184     }
 185
 186   if (string.size () < status_size)
 187     string.puts (n_spaces (status_size - string.size ()));
 188   else if (string.size () > status_size)
 189     string.string ().erase (status_size, string.size ());
 190
 191   return std::move (string.string ());
 192 }
 193
 194 /* Get a printable name for the function at the address.  The symbol
 195    name is demangled if demangling is turned on.  Returns a pointer to
 196    a static area holding the result.  */
 197 static char*
 198 tui_get_function_from_frame (struct frame_info *fi)
 199 {
 200   static char name[256];
 201   string_file stream;
 202
 203   print_address_symbolic (get_frame_arch (fi), get_frame_pc (fi),
 204                           &stream, demangle, "");
 205
 206   /* Use simple heuristics to isolate the function name.  The symbol
 207      can be demangled and we can have function parameters.  Remove
 208      them because the status line is too short to display them.  */
 209   const char *d = stream.c_str ();
 210   if (*d == '<')
 211     d++;
 212   strncpy (name, d, sizeof (name) - 1);
 213   name[sizeof (name) - 1] = 0;
 214
 215   char *p = strchr (name, '(');
 216   if (!p)
 217     p = strchr (name, '>');
 218   if (p)
 219     *p = 0;
 220   p = strchr (name, '+');
 221   if (p)
 222     *p = 0;
 223   return name;
 224 }
 225
 226 void
 227 tui_locator_window::rerender ()
 228 {
 229   if (handle != NULL)
 230     {
 231       std::string string = make_status_line ();
 232       scrollok (handle.get (), FALSE);
 233       wmove (handle.get (), 0, 0);
 234       /* We ignore the return value from wstandout and wstandend, casting
 235          them to void in order to avoid a compiler warning.  The warning
 236          itself was introduced by a patch to ncurses 5.7 dated 2009-08-29,
 237          changing these macro to expand to code that causes the compiler
 238          to generate an unused-value warning.  */
 239       (void) wstandout (handle.get ());
 240       waddstr (handle.get (), string.c_str ());
 241       wclrtoeol (handle.get ());
 242       (void) wstandend (handle.get ());
 243       refresh_window ();
 244       wmove (handle.get (), 0, 0);
 245     }
 246 }
 247
 248 /* See tui-stack.h.  */
 249
 250 void
 251 tui_locator_window::set_locator_fullname (const char *fullname)
 252 {
 253   full_name = fullname;
 254   rerender ();
 255 }
 256
 257 /* See tui-stack.h.  */
 258
 259 bool
 260 tui_locator_window::set_locator_info (struct gdbarch *gdbarch_in,
 261                                       const struct symtab_and_line &sal,
 262                                       const char *procname)
 263 {
 264   bool locator_changed_p = false;
 265
 266   gdb_assert (procname != NULL);
 267
 268   const char *fullname = (sal.symtab == nullptr
 269                           ? "??"
 270                           : symtab_to_fullname (sal.symtab));
 271
 272   locator_changed_p |= proc_name != procname;
 273   locator_changed_p |= sal.line != line_no;
 274   locator_changed_p |= sal.pc != addr;
 275   locator_changed_p |= gdbarch_in != gdbarch;
 276   locator_changed_p |= full_name != fullname;
 277
 278   proc_name = procname;
 279   line_no = sal.line;
 280   addr = sal.pc;
 281   gdbarch = gdbarch_in;
 282   set_locator_fullname (fullname);
 283
 284   return locator_changed_p;
 285 }
 286
 287 /* Update only the full_name portion of the locator.  */
 288 void
 289 tui_update_locator_fullname (struct symtab *symtab)
 290 {
 291   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 292
 293   const char *fullname;
 294   if (symtab != nullptr)
 295     fullname = symtab_to_fullname (symtab);
 296   else
 297     fullname = "??";
 298   locator->set_locator_fullname (fullname);
 299 }
 300
 301 /* Function to print the frame information for the TUI.  The windows are
 302    refreshed only if frame information has changed since the last refresh.
 303
 304    Return true if frame information has changed (and windows
 305    subsequently refreshed), false otherwise.  */
 306
 307 bool
 308 tui_show_frame_info (struct frame_info *fi)
 309 {
 310   bool locator_changed_p;
 311   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 312
 313   if (fi)
 314     {
 315       symtab_and_line sal = find_frame_sal (fi);
 316
 317       const char *func_name;
 318       /* find_frame_sal does not always set PC, but we want to ensure
 319          that it is available in the SAL.  */
 320       if (get_frame_pc_if_available (fi, &sal.pc))
 321         func_name = tui_get_function_from_frame (fi);
 322       else
 323         func_name = _("<unavailable>");
 324
 325       locator_changed_p = locator->set_locator_info (get_frame_arch (fi),
 326                                                      sal, func_name);
 327
 328       /* If the locator information has not changed, then frame information has
 329          not changed.  If frame information has not changed, then the windows'
 330          contents will not change.  So don't bother refreshing the windows.  */
 331       if (!locator_changed_p)
 332         return false;
 333
 334       for (struct tui_source_window_base *win_info : tui_source_windows ())
 335         {
 336           win_info->maybe_update (fi, sal);
 337           win_info->update_exec_info ();
 338         }
 339     }
 340   else
 341     {
 342       symtab_and_line sal {};
 343
 344       locator_changed_p = locator->set_locator_info (NULL, sal, "");
 345
 346       if (!locator_changed_p)
 347         return false;
 348
 349       for (struct tui_source_window_base *win_info : tui_source_windows ())
 350         win_info->erase_source_content ();
 351     }
 352
 353   return true;
 354 }
 355
 356 void
 357 tui_show_locator_content ()
 358 {
 359   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 360   locator->rerender ();
 361 }
 362
 363 /* Command to update the display with the current execution point.  */
 364 static void
 365 tui_update_command (const char *arg, int from_tty)
 366 {
 367   execute_command ("frame 0", from_tty);
 368 }
 369
 370 /* Function to initialize gdb commands, for tui window stack
 371    manipulation.  */
 372
 373 void
 374 _initialize_tui_stack (void)
 375 {
 376   add_com ("update", class_tui, tui_update_command,
 377            _("Update the source window and locator to "
 378              "display the current execution point."));
 379 }