gdb/tui/tui-stack.c

   1 /* TUI display locator.
   2
   3    Copyright (C) 1998-2017 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 /* Get a printable name for the function at the address.
  43    The symbol name is demangled if demangling is turned on.
  44    Returns a pointer to a static area holding the result.  */
  45 static char *tui_get_function_from_frame (struct frame_info *fi);
  46
  47 /* Set the full_name portion of the locator.  */
  48 static void tui_set_locator_fullname (const char *fullname);
  49
  50 /* Update the locator, with the provided arguments.  */
  51 static int tui_set_locator_info (struct gdbarch *gdbarch,
  52                                  const char *fullname,
  53                                  const char *procname,
  54                                  int lineno, CORE_ADDR addr);
  55
  56 static void tui_update_command (const char *, int);
  57 \f
  58
  59 /* Create the status line to display as much information as we can on
  60    this single line: target name, process number, current function,
  61    current line, current PC, SingleKey mode.  */
  62 static char*
  63 tui_make_status_line (struct tui_locator_element *loc)
  64 {
  65   char *string;
  66   char line_buf[50], *pname;
  67   char *buf;
  68   int status_size;
  69   int i, proc_width;
  70   const char *pid_name;
  71   int target_width;
  72   int pid_width;
  73   int line_width;
  74
  75   if (ptid_equal (inferior_ptid, null_ptid))
  76     pid_name = "No process";
  77   else
  78     pid_name = target_pid_to_str (inferior_ptid);
  79
  80   target_width = strlen (target_shortname);
  81   if (target_width > MAX_TARGET_WIDTH)
  82     target_width = MAX_TARGET_WIDTH;
  83
  84   pid_width = strlen (pid_name);
  85   if (pid_width > MAX_PID_WIDTH)
  86     pid_width = MAX_PID_WIDTH;
  87
  88   status_size = tui_term_width ();
  89   string = (char *) xmalloc (status_size + 1);
  90   buf = (char*) alloca (status_size + 1);
  91
  92   /* Translate line number and obtain its size.  */
  93   if (loc->line_no > 0)
  94     xsnprintf (line_buf, sizeof (line_buf), "%d", loc->line_no);
  95   else
  96     strcpy (line_buf, "??");
  97   line_width = strlen (line_buf);
  98   if (line_width < MIN_LINE_WIDTH)
  99     line_width = MIN_LINE_WIDTH;
 100
 101   /* Translate PC address.  */
 102   string_file pc_out;
 103
 104   fputs_filtered (loc->gdbarch? paddress (loc->gdbarch, loc->addr) : "??",
 105                   &pc_out);
 106
 107   const char *pc_buf = pc_out.c_str ();
 108   int pc_width = pc_out.size ();
 109
 110   /* First determine the amount of proc name width we have available.
 111      The +1 are for a space separator between fields.
 112      The -1 are to take into account the \0 counted by sizeof.  */
 113   proc_width = (status_size
 114                 - (target_width + 1)
 115                 - (pid_width + 1)
 116                 - (sizeof (PROC_PREFIX) - 1 + 1)
 117                 - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
 118                 - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
 119                 - (tui_current_key_mode == TUI_SINGLE_KEY_MODE
 120                    ? (sizeof (SINGLE_KEY) - 1 + 1)
 121                    : 0));
 122
 123   /* If there is no room to print the function name, try by removing
 124      some fields.  */
 125   if (proc_width < MIN_PROC_WIDTH)
 126     {
 127       proc_width += target_width + 1;
 128       target_width = 0;
 129       if (proc_width < MIN_PROC_WIDTH)
 130         {
 131           proc_width += pid_width + 1;
 132           pid_width = 0;
 133           if (proc_width <= MIN_PROC_WIDTH)
 134             {
 135               proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
 136               pc_width = 0;
 137               if (proc_width < 0)
 138                 {
 139                   proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
 140                   line_width = 0;
 141                   if (proc_width < 0)
 142                     proc_width = 0;
 143                 }
 144             }
 145         }
 146     }
 147
 148   /* Now convert elements to string form.  */
 149   pname = loc->proc_name;
 150
 151   /* Now create the locator line from the string version of the
 152      elements.  We could use sprintf() here but that wouldn't ensure
 153      that we don't overrun the size of the allocated buffer.
 154      strcat_to_buf() will.  */
 155   *string = (char) 0;
 156
 157   if (target_width > 0)
 158     {
 159       sprintf (buf, "%*.*s ",
 160                -target_width, target_width, target_shortname);
 161       strcat_to_buf (string, status_size, buf);
 162     }
 163   if (pid_width > 0)
 164     {
 165       sprintf (buf, "%*.*s ",
 166                -pid_width, pid_width, pid_name);
 167       strcat_to_buf (string, status_size, buf);
 168     }
 169
 170   /* Show whether we are in SingleKey mode.  */
 171   if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
 172     {
 173       strcat_to_buf (string, status_size, SINGLE_KEY);
 174       strcat_to_buf (string, status_size, " ");
 175     }
 176
 177   /* Procedure/class name.  */
 178   if (proc_width > 0)
 179     {
 180       if (strlen (pname) > proc_width)
 181         sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
 182                  1 - proc_width, proc_width - 1, pname);
 183       else
 184         sprintf (buf, "%s%*.*s ", PROC_PREFIX,
 185                  -proc_width, proc_width, pname);
 186       strcat_to_buf (string, status_size, buf);
 187     }
 188
 189   if (line_width > 0)
 190     {
 191       sprintf (buf, "%s%*.*s ", LINE_PREFIX,
 192                -line_width, line_width, line_buf);
 193       strcat_to_buf (string, status_size, buf);
 194     }
 195   if (pc_width > 0)
 196     {
 197       strcat_to_buf (string, status_size, PC_PREFIX);
 198       strcat_to_buf (string, status_size, pc_buf);
 199     }
 200
 201
 202   for (i = strlen (string); i < status_size; i++)
 203     string[i] = ' ';
 204   string[status_size] = (char) 0;
 205
 206   return string;
 207 }
 208
 209 /* Get a printable name for the function at the address.  The symbol
 210    name is demangled if demangling is turned on.  Returns a pointer to
 211    a static area holding the result.  */
 212 static char*
 213 tui_get_function_from_frame (struct frame_info *fi)
 214 {
 215   static char name[256];
 216   string_file stream;
 217
 218   print_address_symbolic (get_frame_arch (fi), get_frame_pc (fi),
 219                           &stream, demangle, "");
 220
 221   /* Use simple heuristics to isolate the function name.  The symbol
 222      can be demangled and we can have function parameters.  Remove
 223      them because the status line is too short to display them.  */
 224   const char *d = stream.c_str ();
 225   if (*d == '<')
 226     d++;
 227   strncpy (name, d, sizeof (name) - 1);
 228   name[sizeof (name) - 1] = 0;
 229
 230   char *p = strchr (name, '(');
 231   if (!p)
 232     p = strchr (name, '>');
 233   if (p)
 234     *p = 0;
 235   p = strchr (name, '+');
 236   if (p)
 237     *p = 0;
 238   return name;
 239 }
 240
 241 void
 242 tui_show_locator_content (void)
 243 {
 244   char *string;
 245   struct tui_gen_win_info *locator;
 246
 247   locator = tui_locator_win_info_ptr ();
 248
 249   if (locator != NULL && locator->handle != (WINDOW *) NULL)
 250     {
 251       struct tui_win_element *element;
 252
 253       element = locator->content[0];
 254
 255       string = tui_make_status_line (&element->which_element.locator);
 256       wmove (locator->handle, 0, 0);
 257       /* We ignore the return value from wstandout and wstandend, casting
 258          them to void in order to avoid a compiler warning.  The warning
 259          itself was introduced by a patch to ncurses 5.7 dated 2009-08-29,
 260          changing these macro to expand to code that causes the compiler
 261          to generate an unused-value warning.  */
 262       (void) wstandout (locator->handle);
 263       waddstr (locator->handle, string);
 264       wclrtoeol (locator->handle);
 265       (void) wstandend (locator->handle);
 266       tui_refresh_win (locator);
 267       wmove (locator->handle, 0, 0);
 268       xfree (string);
 269       locator->content_in_use = TRUE;
 270     }
 271 }
 272
 273
 274 /* Set the filename portion of the locator.  */
 275 static void
 276 tui_set_locator_fullname (const char *fullname)
 277 {
 278   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
 279   struct tui_locator_element *element;
 280
 281   if (locator->content[0] == NULL)
 282     {
 283       tui_set_locator_info (NULL, fullname, NULL, 0, 0);
 284       return;
 285     }
 286
 287   element = &locator->content[0]->which_element.locator;
 288   element->full_name[0] = 0;
 289   strcat_to_buf (element->full_name, MAX_LOCATOR_ELEMENT_LEN, fullname);
 290 }
 291
 292 /* Update the locator, with the provided arguments.
 293
 294    Returns 1 if any of the locator's fields were actually changed,
 295    and 0 otherwise.  */
 296
 297 static int
 298 tui_set_locator_info (struct gdbarch *gdbarch,
 299                       const char *fullname,
 300                       const char *procname,
 301                       int lineno,
 302                       CORE_ADDR addr)
 303 {
 304   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
 305   struct tui_locator_element *element;
 306   int locator_changed_p = 0;
 307
 308   /* Allocate the locator content if necessary.  */
 309   if (locator->content_size <= 0)
 310     {
 311       locator->content = tui_alloc_content (1, LOCATOR_WIN);
 312       locator->content_size = 1;
 313       locator_changed_p = 1;
 314     }
 315
 316   if (procname == NULL)
 317     procname = "";
 318
 319   if (fullname == NULL)
 320     fullname = "";
 321
 322   element = &locator->content[0]->which_element.locator;
 323
 324   locator_changed_p |= strncmp (element->proc_name, procname,
 325                                 MAX_LOCATOR_ELEMENT_LEN) != 0;
 326   locator_changed_p |= lineno != element->line_no;
 327   locator_changed_p |= addr != element->addr;
 328   locator_changed_p |= gdbarch != element->gdbarch;
 329   locator_changed_p |= strncmp (element->full_name, fullname,
 330                                 MAX_LOCATOR_ELEMENT_LEN) != 0;
 331
 332   element->proc_name[0] = (char) 0;
 333   strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
 334   element->line_no = lineno;
 335   element->addr = addr;
 336   element->gdbarch = gdbarch;
 337   tui_set_locator_fullname (fullname);
 338
 339   return locator_changed_p;
 340 }
 341
 342 /* Update only the full_name portion of the locator.  */
 343 void
 344 tui_update_locator_fullname (const char *fullname)
 345 {
 346   tui_set_locator_fullname (fullname);
 347   tui_show_locator_content ();
 348 }
 349
 350 /* Function to print the frame information for the TUI.  The windows are
 351    refreshed only if frame information has changed since the last refresh.
 352
 353    Return 1 if frame information has changed (and windows subsequently
 354    refreshed), 0 otherwise.  */
 355
 356 int
 357 tui_show_frame_info (struct frame_info *fi)
 358 {
 359   struct tui_win_info *win_info;
 360   int locator_changed_p;
 361   int i;
 362
 363   if (fi)
 364     {
 365       int start_line, i;
 366       CORE_ADDR low;
 367       struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
 368       int source_already_displayed;
 369       CORE_ADDR pc;
 370
 371       symtab_and_line sal = find_frame_sal (fi);
 372
 373       source_already_displayed = sal.symtab != 0
 374         && tui_source_is_displayed (symtab_to_fullname (sal.symtab));
 375
 376       if (get_frame_pc_if_available (fi, &pc))
 377         locator_changed_p
 378           = tui_set_locator_info (get_frame_arch (fi),
 379                                   (sal.symtab == 0
 380                                    ? "??" : symtab_to_fullname (sal.symtab)),
 381                                   tui_get_function_from_frame (fi),
 382                                   sal.line,
 383                                   pc);
 384       else
 385         locator_changed_p
 386           = tui_set_locator_info (get_frame_arch (fi),
 387                                   "??", _("<unavailable>"), sal.line, 0);
 388
 389       /* If the locator information has not changed, then frame information has
 390          not changed.  If frame information has not changed, then the windows'
 391          contents will not change.  So don't bother refreshing the windows.  */
 392       if (!locator_changed_p)
 393         return 0;
 394
 395       tui_show_locator_content ();
 396       start_line = 0;
 397       for (i = 0; i < (tui_source_windows ())->count; i++)
 398         {
 399           union tui_which_element *item;
 400
 401           win_info = (tui_source_windows ())->list[i];
 402
 403           item = &locator->content[0]->which_element;
 404           if (win_info == TUI_SRC_WIN)
 405             {
 406               start_line = (item->locator.line_no -
 407                            (win_info->generic.viewport_height / 2)) + 1;
 408               if (start_line <= 0)
 409                 start_line = 1;
 410             }
 411           else
 412             {
 413               if (find_pc_partial_function (get_frame_pc (fi),
 414                                             (const char **) NULL,
 415                                             &low, NULL) == 0)
 416                 {
 417                   /* There is no symbol available for current PC.  There is no
 418                      safe way how to "disassemble backwards".  */
 419                   low = get_frame_pc (fi);
 420                 }
 421               else
 422                 low = tui_get_low_disassembly_address (get_frame_arch (fi),
 423                                                        low, get_frame_pc (fi));
 424             }
 425
 426           if (win_info == TUI_SRC_WIN)
 427             {
 428               struct tui_line_or_address l;
 429
 430               l.loa = LOA_LINE;
 431               l.u.line_no = start_line;
 432               if (!(source_already_displayed
 433                     && tui_line_is_displayed (item->locator.line_no,
 434                                               win_info, TRUE)))
 435                 tui_update_source_window (win_info, get_frame_arch (fi),
 436                                           sal.symtab, l, TRUE);
 437               else
 438                 {
 439                   l.u.line_no = item->locator.line_no;
 440                   tui_set_is_exec_point_at (l, win_info);
 441                 }
 442             }
 443           else
 444             {
 445               if (win_info == TUI_DISASM_WIN)
 446                 {
 447                   struct tui_line_or_address a;
 448
 449                   a.loa = LOA_ADDRESS;
 450                   a.u.addr = low;
 451                   if (!tui_addr_is_displayed (item->locator.addr,
 452                                               win_info, TRUE))
 453                     tui_update_source_window (win_info, get_frame_arch (fi),
 454                                               sal.symtab, a, TRUE);
 455                   else
 456                     {
 457                       a.u.addr = item->locator.addr;
 458                       tui_set_is_exec_point_at (a, win_info);
 459                     }
 460                 }
 461             }
 462           tui_update_exec_info (win_info);
 463         }
 464
 465       return 1;
 466     }
 467   else
 468     {
 469       locator_changed_p
 470         = tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
 471
 472       if (!locator_changed_p)
 473         return 0;
 474
 475       tui_show_locator_content ();
 476       for (i = 0; i < (tui_source_windows ())->count; i++)
 477         {
 478           win_info = (tui_source_windows ())->list[i];
 479           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 480           tui_update_exec_info (win_info);
 481         }
 482
 483       return 1;
 484     }
 485 }
 486
 487 /* Function to initialize gdb commands, for tui window stack
 488    manipulation.  */
 489
 490 void
 491 _initialize_tui_stack (void)
 492 {
 493   add_com ("update", class_tui, tui_update_command,
 494            _("Update the source window and locator to "
 495              "display the current execution point.\n"));
 496 }
 497
 498 /* Command to update the display with the current execution point.  */
 499 static void
 500 tui_update_command (const char *arg, int from_tty)
 501 {
 502   char cmd[sizeof("frame 0")];
 503
 504   strcpy (cmd, "frame 0");
 505   execute_command (cmd, from_tty);
 506 }