1 /* TUI display locator.
3 Copyright (C) 1998-2018 Free Software Foundation, Inc.
5 Contributed by Hewlett-Packard Company.
7 This file is part of GDB.
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.
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.
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/>. */
24 #include "breakpoint.h"
30 #include "gdb-demangle.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"
40 #include "gdb_curses.h"
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
);
47 /* Set the full_name portion of the locator. */
48 static void tui_set_locator_fullname (const char *fullname
);
50 /* Update the locator, with the provided arguments. */
51 static int tui_set_locator_info (struct gdbarch
*gdbarch
,
54 int lineno
, CORE_ADDR addr
);
56 static void tui_update_command (const char *, int);
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. */
63 tui_make_status_line (struct tui_locator_element
*loc
)
66 char line_buf
[50], *pname
;
75 if (ptid_equal (inferior_ptid
, null_ptid
))
76 pid_name
= "No process";
78 pid_name
= target_pid_to_str (inferior_ptid
);
80 target_width
= strlen (target_shortname
);
81 if (target_width
> MAX_TARGET_WIDTH
)
82 target_width
= MAX_TARGET_WIDTH
;
84 pid_width
= strlen (pid_name
);
85 if (pid_width
> MAX_PID_WIDTH
)
86 pid_width
= MAX_PID_WIDTH
;
88 status_size
= tui_term_width ();
89 string
= (char *) xmalloc (status_size
+ 1);
90 buf
= (char*) alloca (status_size
+ 1);
92 /* Translate line number and obtain its size. */
94 xsnprintf (line_buf
, sizeof (line_buf
), "%d", loc
->line_no
);
96 strcpy (line_buf
, "??");
97 line_width
= strlen (line_buf
);
98 if (line_width
< MIN_LINE_WIDTH
)
99 line_width
= MIN_LINE_WIDTH
;
101 /* Translate PC address. */
104 fputs_filtered (loc
->gdbarch
? paddress (loc
->gdbarch
, loc
->addr
) : "??",
107 const char *pc_buf
= pc_out
.c_str ();
108 int pc_width
= pc_out
.size ();
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
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)
123 /* If there is no room to print the function name, try by removing
125 if (proc_width
< MIN_PROC_WIDTH
)
127 proc_width
+= target_width
+ 1;
129 if (proc_width
< MIN_PROC_WIDTH
)
131 proc_width
+= pid_width
+ 1;
133 if (proc_width
<= MIN_PROC_WIDTH
)
135 proc_width
+= pc_width
+ sizeof (PC_PREFIX
) - 1 + 1;
139 proc_width
+= line_width
+ sizeof (LINE_PREFIX
) - 1 + 1;
148 /* Now convert elements to string form. */
149 pname
= loc
->proc_name
;
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. */
157 if (target_width
> 0)
159 sprintf (buf
, "%*.*s ",
160 -target_width
, target_width
, target_shortname
);
161 strcat_to_buf (string
, status_size
, buf
);
165 sprintf (buf
, "%*.*s ",
166 -pid_width
, pid_width
, pid_name
);
167 strcat_to_buf (string
, status_size
, buf
);
170 /* Show whether we are in SingleKey mode. */
171 if (tui_current_key_mode
== TUI_SINGLE_KEY_MODE
)
173 strcat_to_buf (string
, status_size
, SINGLE_KEY
);
174 strcat_to_buf (string
, status_size
, " ");
177 /* Procedure/class name. */
180 if (strlen (pname
) > proc_width
)
181 sprintf (buf
, "%s%*.*s* ", PROC_PREFIX
,
182 1 - proc_width
, proc_width
- 1, pname
);
184 sprintf (buf
, "%s%*.*s ", PROC_PREFIX
,
185 -proc_width
, proc_width
, pname
);
186 strcat_to_buf (string
, status_size
, buf
);
191 sprintf (buf
, "%s%*.*s ", LINE_PREFIX
,
192 -line_width
, line_width
, line_buf
);
193 strcat_to_buf (string
, status_size
, buf
);
197 strcat_to_buf (string
, status_size
, PC_PREFIX
);
198 strcat_to_buf (string
, status_size
, pc_buf
);
202 for (i
= strlen (string
); i
< status_size
; i
++)
204 string
[status_size
] = (char) 0;
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. */
213 tui_get_function_from_frame (struct frame_info
*fi
)
215 static char name
[256];
218 print_address_symbolic (get_frame_arch (fi
), get_frame_pc (fi
),
219 &stream
, demangle
, "");
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 ();
227 strncpy (name
, d
, sizeof (name
) - 1);
228 name
[sizeof (name
) - 1] = 0;
230 char *p
= strchr (name
, '(');
232 p
= strchr (name
, '>');
235 p
= strchr (name
, '+');
242 tui_show_locator_content (void)
245 struct tui_gen_win_info
*locator
;
247 locator
= tui_locator_win_info_ptr ();
249 if (locator
!= NULL
&& locator
->handle
!= (WINDOW
*) NULL
)
251 struct tui_win_element
*element
;
253 element
= locator
->content
[0];
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);
269 locator
->content_in_use
= TRUE
;
274 /* Set the filename portion of the locator. */
276 tui_set_locator_fullname (const char *fullname
)
278 struct tui_gen_win_info
*locator
= tui_locator_win_info_ptr ();
279 struct tui_locator_element
*element
;
281 if (locator
->content
[0] == NULL
)
283 tui_set_locator_info (NULL
, fullname
, NULL
, 0, 0);
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
);
292 /* Update the locator, with the provided arguments.
294 Returns 1 if any of the locator's fields were actually changed,
298 tui_set_locator_info (struct gdbarch
*gdbarch
,
299 const char *fullname
,
300 const char *procname
,
304 struct tui_gen_win_info
*locator
= tui_locator_win_info_ptr ();
305 struct tui_locator_element
*element
;
306 int locator_changed_p
= 0;
308 /* Allocate the locator content if necessary. */
309 if (locator
->content_size
<= 0)
311 locator
->content
= tui_alloc_content (1, LOCATOR_WIN
);
312 locator
->content_size
= 1;
313 locator_changed_p
= 1;
316 if (procname
== NULL
)
319 if (fullname
== NULL
)
322 element
= &locator
->content
[0]->which_element
.locator
;
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;
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
);
339 return locator_changed_p
;
342 /* Update only the full_name portion of the locator. */
344 tui_update_locator_fullname (const char *fullname
)
346 tui_set_locator_fullname (fullname
);
347 tui_show_locator_content ();
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.
353 Return 1 if frame information has changed (and windows subsequently
354 refreshed), 0 otherwise. */
357 tui_show_frame_info (struct frame_info
*fi
)
359 struct tui_win_info
*win_info
;
360 int locator_changed_p
;
367 struct tui_gen_win_info
*locator
= tui_locator_win_info_ptr ();
368 int source_already_displayed
;
371 symtab_and_line sal
= find_frame_sal (fi
);
373 source_already_displayed
= sal
.symtab
!= 0
374 && tui_source_is_displayed (symtab_to_fullname (sal
.symtab
));
376 if (get_frame_pc_if_available (fi
, &pc
))
378 = tui_set_locator_info (get_frame_arch (fi
),
380 ? "??" : symtab_to_fullname (sal
.symtab
)),
381 tui_get_function_from_frame (fi
),
386 = tui_set_locator_info (get_frame_arch (fi
),
387 "??", _("<unavailable>"), sal
.line
, 0);
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
)
395 tui_show_locator_content ();
397 for (i
= 0; i
< (tui_source_windows ())->count
; i
++)
399 union tui_which_element
*item
;
401 win_info
= (tui_source_windows ())->list
[i
];
403 item
= &locator
->content
[0]->which_element
;
404 if (win_info
== TUI_SRC_WIN
)
406 start_line
= (item
->locator
.line_no
-
407 (win_info
->generic
.viewport_height
/ 2)) + 1;
413 if (find_pc_partial_function (get_frame_pc (fi
),
414 (const char **) NULL
,
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
);
422 low
= tui_get_low_disassembly_address (get_frame_arch (fi
),
423 low
, get_frame_pc (fi
));
426 if (win_info
== TUI_SRC_WIN
)
428 struct tui_line_or_address l
;
431 l
.u
.line_no
= start_line
;
432 if (!(source_already_displayed
433 && tui_line_is_displayed (item
->locator
.line_no
,
435 tui_update_source_window (win_info
, get_frame_arch (fi
),
436 sal
.symtab
, l
, TRUE
);
439 l
.u
.line_no
= item
->locator
.line_no
;
440 tui_set_is_exec_point_at (l
, win_info
);
445 if (win_info
== TUI_DISASM_WIN
)
447 struct tui_line_or_address a
;
451 if (!tui_addr_is_displayed (item
->locator
.addr
,
453 tui_update_source_window (win_info
, get_frame_arch (fi
),
454 sal
.symtab
, a
, TRUE
);
457 a
.u
.addr
= item
->locator
.addr
;
458 tui_set_is_exec_point_at (a
, win_info
);
462 tui_update_exec_info (win_info
);
470 = tui_set_locator_info (NULL
, NULL
, NULL
, 0, (CORE_ADDR
) 0);
472 if (!locator_changed_p
)
475 tui_show_locator_content ();
476 for (i
= 0; i
< (tui_source_windows ())->count
; i
++)
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
);
487 /* Function to initialize gdb commands, for tui window stack
491 _initialize_tui_stack (void)
493 add_com ("update", class_tui
, tui_update_command
,
494 _("Update the source window and locator to "
495 "display the current execution point.\n"));
498 /* Command to update the display with the current execution point. */
500 tui_update_command (const char *arg
, int from_tty
)
502 execute_command ("frame 0", from_tty
);
This page took 0.053226 seconds and 4 git commands to generate.