GDB (xrefs)
tui-stack.c
Go to the documentation of this file.
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 
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*
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 
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)
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. */
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*
216 {
217  static char name[256];
218  struct ui_file *stream = tui_sfileopen (256);
219  char *p;
220 
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
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
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,
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,
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);
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
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
379 
380  if (get_frame_pc_if_available (fi, &pc))
381  locator_changed_p
383  (sal.symtab == 0
384  ? "??" : symtab_to_fullname (sal.symtab)),
386  sal.line,
387  pc);
388  else
389  locator_changed_p
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 
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  {
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
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
438  win_info, TRUE)))
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))
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 
480  for (i = 0; i < (tui_source_windows ())->count; i++)
481  {
482  win_info = (tui_source_windows ())->list[i];
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. */
496 
497 void
499 {
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 }
#define MIN_LINE_WIDTH
Definition: tui-data.h:89
const char * string
Definition: signals.c:50
int demangle
Definition: demangle.c:49
tui_win_content content
Definition: tui-data.h:47
char * tui_file_get_strbuf(struct ui_file *file)
Definition: tui-file.c:190
int viewport_height
Definition: tui-data.h:50
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define target_shortname
Definition: target.h:1242
void xfree(void *)
Definition: common-utils.c:97
static char * tui_get_function_from_frame(struct frame_info *fi)
Definition: tui-stack.c:215
void ui_file_delete(struct ui_file *file)
Definition: ui-file.c:76
initialize_file_ftype _initialize_tui_stack
int get_frame_pc_if_available(struct frame_info *frame, CORE_ADDR *pc)
Definition: frame.c:2224
#define MIN_PROC_WIDTH
Definition: tui-data.h:91
struct tui_list * tui_source_windows(void)
Definition: tui-data.c:159
int tui_source_is_displayed(const char *fullname)
Definition: tui-source.c:335
void tui_update_exec_info(struct tui_win_info *win_info)
union tui_line_or_address::@171 u
static void tui_set_locator_fullname(const char *fullname)
Definition: tui-stack.c:279
void tui_set_is_exec_point_at(struct tui_line_or_address l, struct tui_win_info *win_info)
char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2233
#define _(String)
Definition: gdb_locale.h:40
void execute_command(char *, int)
Definition: top.c:388
WINDOW * handle
Definition: tui-data.h:42
#define LINE_PREFIX
Definition: tui-data.h:83
enum tui_line_or_address_kind loa
Definition: tui-data.h:142
static void tui_update_command(char *, int)
Definition: tui-stack.c:507
void tui_update_locator_fullname(const char *fullname)
Definition: tui-stack.c:347
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
void tui_update_source_window(struct tui_win_info *win_info, struct gdbarch *gdbarch, struct symtab *s, struct tui_line_or_address line_or_addr, int noerror)
Definition: tui-winsource.c:71
char full_name[MAX_LOCATOR_ELEMENT_LEN]
Definition: tui-data.h:196
void find_frame_sal(struct frame_info *frame, struct symtab_and_line *sal)
Definition: frame.c:2328
const char *const name
Definition: aarch64-tdep.c:68
struct tui_locator_element locator
Definition: tui-data.h:226
static int tui_set_locator_info(struct gdbarch *gdbarch, const char *fullname, const char *procname, int lineno, CORE_ADDR addr)
Definition: tui-stack.c:301
struct tui_gen_win_info generic
Definition: tui-data.h:277
void initialize_file_ftype(void)
Definition: defs.h:281
tui_win_content tui_alloc_content(int num_elements, enum tui_win_type type)
Definition: tui-data.c:577
CORE_ADDR addr
Definition: tui-data.h:199
struct ui_file * tui_sfileopen(int n)
Definition: tui-file.c:101
void strcat_to_buf(char *buf, int buflen, const char *item_to_add)
Definition: tui.c:560
void tui_clear_source_content(struct tui_win_info *win_info, int display_prompt)
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
struct tui_gen_win_info * tui_locator_win_info_ptr(void)
Definition: tui-data.c:254
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:321
#define MAX_TARGET_WIDTH
Definition: tui-data.h:92
int tui_addr_is_displayed(CORE_ADDR addr, struct tui_win_info *win_info, int check_threshold)
#define MAX_PID_WIDTH
Definition: tui-data.h:93
void * xmalloc(YYSIZE_T)
struct symtab * symtab
Definition: symtab.h:1369
struct gdbarch * gdbarch
Definition: tui-data.h:201
static char * tui_make_status_line(struct tui_locator_element *loc)
Definition: tui-stack.c:63
void tui_show_locator_content(void)
Definition: tui-stack.c:245
union tui_which_element which_element
Definition: tui-data.h:233
int content_in_use
Definition: tui-data.h:49
int print_address_symbolic(struct gdbarch *, CORE_ADDR, struct ui_file *, int, char *)
Definition: printcmd.c:556
#define TUI_SRC_WIN
Definition: tui-data.h:300
ptid_t null_ptid
Definition: ptid.c:25
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
ptid_t inferior_ptid
Definition: infcmd.c:124
int tui_term_width(void)
Definition: tui-data.c:278
#define MAX_LOCATOR_ELEMENT_LEN
Definition: tui-data.h:189
CORE_ADDR pc
Definition: symtab.h:1376
#define SINGLE_KEY
Definition: tui-data.h:85
#define TUI_DISASM_WIN
Definition: tui-data.h:301
#define PROC_PREFIX
Definition: tui-data.h:82
int tui_show_frame_info(struct frame_info *fi)
Definition: tui-stack.c:360
#define EMPTY_SOURCE_PROMPT
Definition: tui-data.h:75
void tui_refresh_win(struct tui_gen_win_info *win_info)
enum tui_key_mode tui_current_key_mode
Definition: tui.c:62
CORE_ADDR addr
Definition: tui-data.h:146
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:873
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
char proc_name[MAX_LOCATOR_ELEMENT_LEN]
Definition: tui-data.h:197
int tui_line_is_displayed(int line, struct tui_win_info *win_info, int check_threshold)
CORE_ADDR tui_get_low_disassembly_address(struct gdbarch *gdbarch, CORE_ADDR low, CORE_ADDR pc)
Definition: tui-disasm.c:368
#define PC_PREFIX
Definition: tui-data.h:84