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_show_locator_content (void)
 258 {
 259   char *string;
 260   struct tui_locator_window *locator;
 261
 262   locator = tui_locator_win_info_ptr ();
 263
 264   if (locator != NULL && locator->handle != NULL)
 265     {
 266       string = tui_make_status_line (locator);
 267       wmove (locator->handle, 0, 0);
 268       /* We ignore the return value from wstandout and wstandend, casting
 269          them to void in order to avoid a compiler warning.  The warning
 270          itself was introduced by a patch to ncurses 5.7 dated 2009-08-29,
 271          changing these macro to expand to code that causes the compiler
 272          to generate an unused-value warning.  */
 273       (void) wstandout (locator->handle);
 274       waddstr (locator->handle, string);
 275       wclrtoeol (locator->handle);
 276       (void) wstandend (locator->handle);
 277       locator->refresh_window ();
 278       wmove (locator->handle, 0, 0);
 279       xfree (string);
 280     }
 281 }
 282
 283 void
 284 tui_locator_window::rerender ()
 285 {
 286   tui_show_locator_content ();
 287 }
 288
 289 /* See tui-stack.h.  */
 290
 291 void
 292 tui_locator_window::set_locator_fullname (const char *fullname)
 293 {
 294   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 295
 296   locator->full_name[0] = 0;
 297   strcat_to_buf (locator->full_name, MAX_LOCATOR_ELEMENT_LEN, fullname);
 298 }
 299
 300 /* See tui-stack.h.  */
 301
 302 bool
 303 tui_locator_window::set_locator_info (struct gdbarch *gdbarch_in,
 304                                       const char *fullname,
 305                                       const char *procname,
 306                                       int lineno,
 307                                       CORE_ADDR addr_in)
 308 {
 309   bool locator_changed_p = false;
 310
 311   if (procname == NULL)
 312     procname = "";
 313
 314   if (fullname == NULL)
 315     fullname = "";
 316
 317   locator_changed_p |= strncmp (proc_name, procname,
 318                                 MAX_LOCATOR_ELEMENT_LEN) != 0;
 319   locator_changed_p |= lineno != line_no;
 320   locator_changed_p |= addr_in != addr;
 321   locator_changed_p |= gdbarch_in != gdbarch;
 322   locator_changed_p |= strncmp (full_name, fullname,
 323                                 MAX_LOCATOR_ELEMENT_LEN) != 0;
 324
 325   proc_name[0] = (char) 0;
 326   strcat_to_buf (proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
 327   line_no = lineno;
 328   addr = addr_in;
 329   gdbarch = gdbarch_in;
 330   set_locator_fullname (fullname);
 331
 332   return locator_changed_p;
 333 }
 334
 335 /* Update only the full_name portion of the locator.  */
 336 void
 337 tui_update_locator_fullname (const char *fullname)
 338 {
 339   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 340
 341   locator->set_locator_fullname (fullname);
 342   tui_show_locator_content ();
 343 }
 344
 345 /* Function to print the frame information for the TUI.  The windows are
 346    refreshed only if frame information has changed since the last refresh.
 347
 348    Return 1 if frame information has changed (and windows subsequently
 349    refreshed), 0 otherwise.  */
 350
 351 int
 352 tui_show_frame_info (struct frame_info *fi)
 353 {
 354   bool locator_changed_p;
 355   struct tui_locator_window *locator = tui_locator_win_info_ptr ();
 356
 357   if (fi)
 358     {
 359       CORE_ADDR pc;
 360
 361       symtab_and_line sal = find_frame_sal (fi);
 362
 363       const char *fullname = nullptr;
 364       if (sal.symtab != nullptr)
 365         fullname = symtab_to_fullname (sal.symtab);
 366
 367       if (get_frame_pc_if_available (fi, &pc))
 368         locator_changed_p
 369           = locator->set_locator_info (get_frame_arch (fi),
 370                                        (sal.symtab == 0
 371                                         ? "??" : fullname),
 372                                        tui_get_function_from_frame (fi),
 373                                        sal.line,
 374                                        pc);
 375       else
 376         locator_changed_p
 377           = locator->set_locator_info (get_frame_arch (fi),
 378                                        "??", _("<unavailable>"), sal.line, 0);
 379
 380       /* If the locator information has not changed, then frame information has
 381          not changed.  If frame information has not changed, then the windows'
 382          contents will not change.  So don't bother refreshing the windows.  */
 383       if (!locator_changed_p)
 384         return 0;
 385
 386       tui_show_locator_content ();
 387       for (struct tui_source_window_base *win_info : tui_source_windows ())
 388         {
 389           win_info->maybe_update (fi, sal, locator->line_no, locator->addr);
 390           win_info->update_exec_info ();
 391         }
 392
 393       return 1;
 394     }
 395   else
 396     {
 397       locator_changed_p
 398         = locator->set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
 399
 400       if (!locator_changed_p)
 401         return 0;
 402
 403       tui_show_locator_content ();
 404       for (struct tui_source_window_base *win_info : tui_source_windows ())
 405         {
 406           win_info->erase_source_content ();
 407           win_info->update_exec_info ();
 408         }
 409
 410       return 1;
 411     }
 412 }
 413
 414 /* Function to initialize gdb commands, for tui window stack
 415    manipulation.  */
 416
 417 void
 418 _initialize_tui_stack (void)
 419 {
 420   add_com ("update", class_tui, tui_update_command,
 421            _("Update the source window and locator to "
 422              "display the current execution point."));
 423 }
 424
 425 /* Command to update the display with the current execution point.  */
 426 static void
 427 tui_update_command (const char *arg, int from_tty)
 428 {
 429   execute_command ("frame 0", from_tty);
 430 }