contrib/gdb-7/gdb/tui/tui-stack.c

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