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 /* Get a printable name for the function at the address.
  57    The symbol name is demangled if demangling is turned on.
  58    Returns a pointer to a static area holding the result.  */
  59 static char *tui_get_function_from_frame (struct frame_info *fi);
  60
  61 static void tui_update_command (const char *, int);
  62 \f
  63
  64 /* Accessor for the locator win info.  Answers a pointer to the static
  65    locator win info struct.  */
  66 struct tui_locator_window *
  67 tui_locator_win_info_ptr (void)
  68 {
  69   return &_locator;
  70 }
  71
  72 /* Create the status line to display as much information as we can on
  73    this single line: target name, process number, current function,
  74    current line, current PC, SingleKey mode.  */
  75 static char *
  76 tui_make_status_line (struct tui_locator_window *loc)
  77 {
  78   char *string;
  79   char line_buf[50], *pname;
  80   char *buf;
  81   int status_size;
  82   int i, proc_width;
  83   const char *pid_name;
  84   int target_width;
  85   int pid_width;
  86   int line_width;
  87
  88   std::string pid_name_holder;
  89   if (inferior_ptid == null_ptid)
  90     pid_name = "No process";
  91   else
  92     {
  93       pid_name_holder = target_pid_to_str (inferior_ptid);
  94       pid_name = pid_name_holder.c_str ();
  95     }
  96
  97   target_width = strlen (target_shortname);
  98   if (target_width > MAX_TARGET_WIDTH)
  99     target_width = MAX_TARGET_WIDTH;
 100
 101   pid_width = strlen (pid_name);
 102   if (pid_width > MAX_PID_WIDTH)
 103     pid_width = MAX_PID_WIDTH;
 104
 105   status_size = tui_term_width ();
 106   string = (char *) xmalloc (status_size + 1);
 107   buf = (char*) alloca (status_size + 1);
 108
 109   /* Translate line number and obtain its size.  */
 110   if (loc->line_no > 0)
 111     xsnprintf (line_buf, sizeof (line_buf), "%d", loc->line_no);
 112   else
 113     strcpy (line_buf, "??");
 114   line_width = strlen (line_buf);
 115   if (line_width < MIN_LINE_WIDTH)
 116     line_width = MIN_LINE_WIDTH;
 117
 118   /* Translate PC address.  */
 119   std::string pc_out (loc->gdbarch
 120                       ? paddress (loc->gdbarch, loc->addr)
 121                       : "??");
 122   const char *pc_buf = pc_out.c_str ();
 123   int pc_width = pc_out.size ();
 124
 125   /* First determine the amount of proc name width we have available.
 126      The +1 are for a space separator between fields.
 127      The -1 are to take into account the \0 counted by sizeof.  */
 128   proc_width = (status_size
 129                 - (target_width + 1)
 130                 - (pid_width + 1)
 131                 - (sizeof (PROC_PREFIX) - 1 + 1)
 132                 - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
 133                 - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
 134                 - (tui_current_key_mode == TUI_SINGLE_KEY_MODE
 135                    ? (sizeof (SINGLE_KEY) - 1 + 1)
 136                    : 0));
 137
 138   /* If there is no room to print the function name, try by removing
 139      some fields.  */
 140   if (proc_width < MIN_PROC_WIDTH)
 141     {
 142       proc_width += target_width + 1;
 143       target_width = 0;
 144       if (proc_width < MIN_PROC_WIDTH)
 145         {
 146           proc_width += pid_width + 1;
 147           pid_width = 0;
 148           if (proc_width <= MIN_PROC_WIDTH)
 149             {
 150               proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
 151               pc_width = 0;
 152               if (proc_width < 0)
 153                 {
 154                   proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
 155                   line_width = 0;
 156                   if (proc_width < 0)
 157                     proc_width = 0;
 158                 }
 159             }
 160         }
 161     }
 162
 163   /* Now convert elements to string form.  */
 164   pname = loc->proc_name;
 165
 166   /* Now create the locator line from the string version of the
 167      elements.  We could use sprintf() here but that wouldn't ensure
 168      that we don't overrun the size of the allocated buffer.
 169      strcat_to_buf() will.  */
 170   *string = (char) 0;
 171
 172   if (target_width > 0)
 173     {
 174       sprintf (buf, "%*.*s ",
 175                -target_width, target_width, target_shortname);
 176       strcat_to_buf (string, status_size, buf);
 177     }
 178   if (pid_width > 0)
 179     {
 180       sprintf (buf, "%*.*s ",
 181                -pid_width, pid_width, pid_name);
 182       strcat_to_buf (string, status_size, buf);
 183     }
 184
 185   /* Show whether we are in SingleKey mode.  */
 186   if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
 187     {
 188       strcat_to_buf (string, status_size, SINGLE_KEY);
 189       strcat_to_buf (string, status_size, " ");
 190     }
 191
 192   /* Procedure/class name.  */
 193   if (proc_width > 0)
 194     {
 195       if (strlen (pname) > proc_width)
 196         sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
 197                  1 - proc_width, proc_width - 1, pname);
 198       else
 199         sprintf (buf, "%s%*.*s ", PROC_PREFIX,
 200                  -proc_width, proc_width, pname);
 201       strcat_to_buf (string, status_size, buf);
 202     }
 203
 204   if (line_width > 0)
 205     {
 206       sprintf (buf, "%s%*.*s ", LINE_PREFIX,
 207                -line_width, line_width, line_buf);
 208       strcat_to_buf (string, status_size, buf);
 209     }
 210   if (pc_width > 0)
 211     {
 212       strcat_to_buf (string, status_size, PC_PREFIX);
 213       strcat_to_buf (string, status_size, pc_buf);
 214     }
 215
 216
 217   for (i = strlen (string); i < status_size; i++)
 218     string[i] = ' ';
 219   string[status_size] = (char) 0;
 220
 221   return string;
 222 }
 223
 224 /* Get a printable name for the function at the address.  The symbol
 225    name is demangled if demangling is turned on.  Returns a pointer to
 226    a static area holding the result.  */
 227 static char*
 228 tui_get_function_from_frame (struct frame_info *fi)
 229 {
 230   static char name[256];
 231   string_file stream;
 232
 233   print_address_symbolic (get_frame_arch (fi), get_frame_pc (fi),
 234                           &stream, demangle, "");
 235
 236   /* Use simple heuristics to isolate the function name.  The symbol
 237      can be demangled and we can have function parameters.  Remove
 238      them because the status line is too short to display them.  */
 239   const char *d = stream.c_str ();
 240   if (*d == '<')
 241     d++;
 242   strncpy (name, d, sizeof (name) - 1);
 243   name[sizeof (name) - 1] = 0;
 244
 245   char *p = strchr (name, '(');
 246   if (!p)
 247     p = strchr (name, '>');
 248   if (p)
 249     *p = 0;
 250   p = strchr (name, '+');
 251   if (p)
 252     *p = 0;
 253   return name;
 254 }
 255
 256 void
 257 tui_locator_window::rerender ()
 258 {
 259   if (handle != NULL)
 260     {
 261       char *string = tui_make_status_line (this);
 262       wmove (handle, 0, 0);
 263       /* We ignore the return value from wstandout and wstandend, casting
 264          them to void in order to avoid a compiler warning.  The warning
 265          itself was introduced by a patch to ncurses 5.7 dated 2009-08-29,
 266          changing these macro to expand to code that causes the compiler
 267          to generate an unused-value warning.  */
 268       (void) wstandout (handle);
 269       waddstr (handle, string);
 270       wclrtoeol (handle);
 271       (void) wstandend (handle);
 272       refresh_window ();
 273       wmove (handle, 0, 0);
 274       xfree (string);
 275     }
 276 }
 277
 278 /* See tui-stack.h.  */
 279
 280 void
 281 tui_locator_window::set_locator_fullname (const char *fullname)
 282 {
 283   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 284
 285   locator->full_name[0] = 0;
 286   strcat_to_buf (locator->full_name, MAX_LOCATOR_ELEMENT_LEN, fullname);
 287 }
 288
 289 /* See tui-stack.h.  */
 290
 291 bool
 292 tui_locator_window::set_locator_info (struct gdbarch *gdbarch_in,
 293                                       const char *fullname,
 294                                       const char *procname,
 295                                       int lineno,
 296                                       CORE_ADDR addr_in)
 297 {
 298   bool locator_changed_p = false;
 299
 300   if (procname == NULL)
 301     procname = "";
 302
 303   if (fullname == NULL)
 304     fullname = "";
 305
 306   locator_changed_p |= strncmp (proc_name, procname,
 307                                 MAX_LOCATOR_ELEMENT_LEN) != 0;
 308   locator_changed_p |= lineno != line_no;
 309   locator_changed_p |= addr_in != addr;
 310   locator_changed_p |= gdbarch_in != gdbarch;
 311   locator_changed_p |= strncmp (full_name, fullname,
 312                                 MAX_LOCATOR_ELEMENT_LEN) != 0;
 313
 314   proc_name[0] = (char) 0;
 315   strcat_to_buf (proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
 316   line_no = lineno;
 317   addr = addr_in;
 318   gdbarch = gdbarch_in;
 319   set_locator_fullname (fullname);
 320
 321   return locator_changed_p;
 322 }
 323
 324 /* Update only the full_name portion of the locator.  */
 325 void
 326 tui_update_locator_fullname (const char *fullname)
 327 {
 328   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 329
 330   locator->set_locator_fullname (fullname);
 331   tui_show_locator_content ();
 332 }
 333
 334 /* Function to print the frame information for the TUI.  The windows are
 335    refreshed only if frame information has changed since the last refresh.
 336
 337    Return 1 if frame information has changed (and windows subsequently
 338    refreshed), 0 otherwise.  */
 339
 340 int
 341 tui_show_frame_info (struct frame_info *fi)
 342 {
 343   bool locator_changed_p;
 344   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 345
 346   if (fi)
 347     {
 348       CORE_ADDR pc;
 349
 350       symtab_and_line sal = find_frame_sal (fi);
 351
 352       const char *fullname = nullptr;
 353       if (sal.symtab != nullptr)
 354         fullname = symtab_to_fullname (sal.symtab);
 355
 356       if (get_frame_pc_if_available (fi, &pc))
 357         locator_changed_p
 358           = locator->set_locator_info (get_frame_arch (fi),
 359                                        (sal.symtab == 0
 360                                         ? "??" : fullname),
 361                                        tui_get_function_from_frame (fi),
 362                                        sal.line,
 363                                        pc);
 364       else
 365         locator_changed_p
 366           = locator->set_locator_info (get_frame_arch (fi),
 367                                        "??", _("<unavailable>"), sal.line, 0);
 368
 369       /* If the locator information has not changed, then frame information has
 370          not changed.  If frame information has not changed, then the windows'
 371          contents will not change.  So don't bother refreshing the windows.  */
 372       if (!locator_changed_p)
 373         return 0;
 374
 375       tui_show_locator_content ();
 376       for (struct tui_source_window_base *win_info : tui_source_windows ())
 377         {
 378           win_info->maybe_update (fi, sal, locator->line_no, locator->addr);
 379           win_info->update_exec_info ();
 380         }
 381
 382       return 1;
 383     }
 384   else
 385     {
 386       locator_changed_p
 387         = locator->set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
 388
 389       if (!locator_changed_p)
 390         return 0;
 391
 392       tui_show_locator_content ();
 393       for (struct tui_source_window_base *win_info : tui_source_windows ())
 394         {
 395           win_info->erase_source_content ();
 396           win_info->update_exec_info ();
 397         }
 398
 399       return 1;
 400     }
 401 }
 402
 403 void
 404 tui_show_locator_content ()
 405 {
 406   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 407   locator->rerender ();
 408 }
 409
 410 /* Function to initialize gdb commands, for tui window stack
 411    manipulation.  */
 412
 413 void
 414 _initialize_tui_stack (void)
 415 {
 416   add_com ("update", class_tui, tui_update_command,
 417            _("Update the source window and locator to "
 418              "display the current execution point."));
 419 }
 420
 421 /* Command to update the display with the current execution point.  */
 422 static void
 423 tui_update_command (const char *arg, int from_tty)
 424 {
 425   execute_command ("frame 0", from_tty);
 426 }