1 /* TUI display locator.
3 Copyright (C) 1998-2019 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 static struct tui_locator_window _locator
;
44 /* Get a printable name for the function at the address.
45 The symbol name is demangled if demangling is turned on.
46 Returns a pointer to a static area holding the result. */
47 static char *tui_get_function_from_frame (struct frame_info
*fi
);
49 /* Set the full_name portion of the locator. */
50 static void tui_set_locator_fullname (const char *fullname
);
52 /* Update the locator, with the provided arguments. */
53 static int tui_set_locator_info (struct gdbarch
*gdbarch
,
56 int lineno
, CORE_ADDR addr
);
58 static void tui_update_command (const char *, int);
61 /* Accessor for the locator win info. Answers a pointer to the static
62 locator win info struct. */
63 struct tui_locator_window
*
64 tui_locator_win_info_ptr (void)
70 tui_initialize_static_data ()
72 tui_gen_win_info
*win
= tui_locator_win_info_ptr ();
77 win
->viewport_height
= 0;
79 win
->is_visible
= false;
84 /* Create the status line to display as much information as we can on
85 this single line: target name, process number, current function,
86 current line, current PC, SingleKey mode. */
88 tui_make_status_line (struct tui_locator_window
*loc
)
91 char line_buf
[50], *pname
;
100 std::string pid_name_holder
;
101 if (inferior_ptid
== null_ptid
)
102 pid_name
= "No process";
105 pid_name_holder
= target_pid_to_str (inferior_ptid
);
106 pid_name
= pid_name_holder
.c_str ();
109 target_width
= strlen (target_shortname
);
110 if (target_width
> MAX_TARGET_WIDTH
)
111 target_width
= MAX_TARGET_WIDTH
;
113 pid_width
= strlen (pid_name
);
114 if (pid_width
> MAX_PID_WIDTH
)
115 pid_width
= MAX_PID_WIDTH
;
117 status_size
= tui_term_width ();
118 string
= (char *) xmalloc (status_size
+ 1);
119 buf
= (char*) alloca (status_size
+ 1);
121 /* Translate line number and obtain its size. */
122 if (loc
->line_no
> 0)
123 xsnprintf (line_buf
, sizeof (line_buf
), "%d", loc
->line_no
);
125 strcpy (line_buf
, "??");
126 line_width
= strlen (line_buf
);
127 if (line_width
< MIN_LINE_WIDTH
)
128 line_width
= MIN_LINE_WIDTH
;
130 /* Translate PC address. */
133 fputs_filtered (loc
->gdbarch
? paddress (loc
->gdbarch
, loc
->addr
) : "??",
136 const char *pc_buf
= pc_out
.c_str ();
137 int pc_width
= pc_out
.size ();
139 /* First determine the amount of proc name width we have available.
140 The +1 are for a space separator between fields.
141 The -1 are to take into account the \0 counted by sizeof. */
142 proc_width
= (status_size
145 - (sizeof (PROC_PREFIX
) - 1 + 1)
146 - (sizeof (LINE_PREFIX
) - 1 + line_width
+ 1)
147 - (sizeof (PC_PREFIX
) - 1 + pc_width
+ 1)
148 - (tui_current_key_mode
== TUI_SINGLE_KEY_MODE
149 ? (sizeof (SINGLE_KEY
) - 1 + 1)
152 /* If there is no room to print the function name, try by removing
154 if (proc_width
< MIN_PROC_WIDTH
)
156 proc_width
+= target_width
+ 1;
158 if (proc_width
< MIN_PROC_WIDTH
)
160 proc_width
+= pid_width
+ 1;
162 if (proc_width
<= MIN_PROC_WIDTH
)
164 proc_width
+= pc_width
+ sizeof (PC_PREFIX
) - 1 + 1;
168 proc_width
+= line_width
+ sizeof (LINE_PREFIX
) - 1 + 1;
177 /* Now convert elements to string form. */
178 pname
= loc
->proc_name
;
180 /* Now create the locator line from the string version of the
181 elements. We could use sprintf() here but that wouldn't ensure
182 that we don't overrun the size of the allocated buffer.
183 strcat_to_buf() will. */
186 if (target_width
> 0)
188 sprintf (buf
, "%*.*s ",
189 -target_width
, target_width
, target_shortname
);
190 strcat_to_buf (string
, status_size
, buf
);
194 sprintf (buf
, "%*.*s ",
195 -pid_width
, pid_width
, pid_name
);
196 strcat_to_buf (string
, status_size
, buf
);
199 /* Show whether we are in SingleKey mode. */
200 if (tui_current_key_mode
== TUI_SINGLE_KEY_MODE
)
202 strcat_to_buf (string
, status_size
, SINGLE_KEY
);
203 strcat_to_buf (string
, status_size
, " ");
206 /* Procedure/class name. */
209 if (strlen (pname
) > proc_width
)
210 sprintf (buf
, "%s%*.*s* ", PROC_PREFIX
,
211 1 - proc_width
, proc_width
- 1, pname
);
213 sprintf (buf
, "%s%*.*s ", PROC_PREFIX
,
214 -proc_width
, proc_width
, pname
);
215 strcat_to_buf (string
, status_size
, buf
);
220 sprintf (buf
, "%s%*.*s ", LINE_PREFIX
,
221 -line_width
, line_width
, line_buf
);
222 strcat_to_buf (string
, status_size
, buf
);
226 strcat_to_buf (string
, status_size
, PC_PREFIX
);
227 strcat_to_buf (string
, status_size
, pc_buf
);
231 for (i
= strlen (string
); i
< status_size
; i
++)
233 string
[status_size
] = (char) 0;
238 /* Get a printable name for the function at the address. The symbol
239 name is demangled if demangling is turned on. Returns a pointer to
240 a static area holding the result. */
242 tui_get_function_from_frame (struct frame_info
*fi
)
244 static char name
[256];
247 print_address_symbolic (get_frame_arch (fi
), get_frame_pc (fi
),
248 &stream
, demangle
, "");
250 /* Use simple heuristics to isolate the function name. The symbol
251 can be demangled and we can have function parameters. Remove
252 them because the status line is too short to display them. */
253 const char *d
= stream
.c_str ();
256 strncpy (name
, d
, sizeof (name
) - 1);
257 name
[sizeof (name
) - 1] = 0;
259 char *p
= strchr (name
, '(');
261 p
= strchr (name
, '>');
264 p
= strchr (name
, '+');
271 tui_show_locator_content (void)
274 struct tui_locator_window
*locator
;
276 locator
= tui_locator_win_info_ptr ();
278 if (locator
!= NULL
&& locator
->handle
!= NULL
)
280 string
= tui_make_status_line (locator
);
281 wmove (locator
->handle
, 0, 0);
282 /* We ignore the return value from wstandout and wstandend, casting
283 them to void in order to avoid a compiler warning. The warning
284 itself was introduced by a patch to ncurses 5.7 dated 2009-08-29,
285 changing these macro to expand to code that causes the compiler
286 to generate an unused-value warning. */
287 (void) wstandout (locator
->handle
);
288 waddstr (locator
->handle
, string
);
289 wclrtoeol (locator
->handle
);
290 (void) wstandend (locator
->handle
);
291 locator
->refresh_window ();
292 wmove (locator
->handle
, 0, 0);
298 /* Set the filename portion of the locator. */
300 tui_set_locator_fullname (const char *fullname
)
302 struct tui_locator_window
*locator
= tui_locator_win_info_ptr ();
304 locator
->full_name
[0] = 0;
305 strcat_to_buf (locator
->full_name
, MAX_LOCATOR_ELEMENT_LEN
, fullname
);
308 /* Update the locator, with the provided arguments.
310 Returns 1 if any of the locator's fields were actually changed,
314 tui_set_locator_info (struct gdbarch
*gdbarch
,
315 const char *fullname
,
316 const char *procname
,
320 struct tui_locator_window
*locator
= tui_locator_win_info_ptr ();
321 int locator_changed_p
= 0;
323 if (procname
== NULL
)
326 if (fullname
== NULL
)
329 locator_changed_p
|= strncmp (locator
->proc_name
, procname
,
330 MAX_LOCATOR_ELEMENT_LEN
) != 0;
331 locator_changed_p
|= lineno
!= locator
->line_no
;
332 locator_changed_p
|= addr
!= locator
->addr
;
333 locator_changed_p
|= gdbarch
!= locator
->gdbarch
;
334 locator_changed_p
|= strncmp (locator
->full_name
, fullname
,
335 MAX_LOCATOR_ELEMENT_LEN
) != 0;
337 locator
->proc_name
[0] = (char) 0;
338 strcat_to_buf (locator
->proc_name
, MAX_LOCATOR_ELEMENT_LEN
, procname
);
339 locator
->line_no
= lineno
;
340 locator
->addr
= addr
;
341 locator
->gdbarch
= gdbarch
;
342 tui_set_locator_fullname (fullname
);
344 return locator_changed_p
;
347 /* Update only the full_name portion of the locator. */
349 tui_update_locator_fullname (const char *fullname
)
351 tui_set_locator_fullname (fullname
);
352 tui_show_locator_content ();
355 /* Function to print the frame information for the TUI. The windows are
356 refreshed only if frame information has changed since the last refresh.
358 Return 1 if frame information has changed (and windows subsequently
359 refreshed), 0 otherwise. */
362 tui_show_frame_info (struct frame_info
*fi
)
364 int locator_changed_p
;
368 struct tui_locator_window
*locator
= tui_locator_win_info_ptr ();
369 int source_already_displayed
;
372 symtab_and_line sal
= find_frame_sal (fi
);
374 const char *fullname
= nullptr;
375 if (sal
.symtab
!= nullptr)
376 fullname
= symtab_to_fullname (sal
.symtab
);
378 source_already_displayed
= (sal
.symtab
!= 0
379 && TUI_SRC_WIN
!= nullptr
380 && TUI_SRC_WIN
->showing_source_p (fullname
));
382 if (get_frame_pc_if_available (fi
, &pc
))
384 = tui_set_locator_info (get_frame_arch (fi
),
387 tui_get_function_from_frame (fi
),
392 = tui_set_locator_info (get_frame_arch (fi
),
393 "??", _("<unavailable>"), sal
.line
, 0);
395 /* If the locator information has not changed, then frame information has
396 not changed. If frame information has not changed, then the windows'
397 contents will not change. So don't bother refreshing the windows. */
398 if (!locator_changed_p
)
401 tui_show_locator_content ();
402 for (struct tui_source_window_base
*win_info
: tui_source_windows ())
404 if (win_info
== TUI_SRC_WIN
)
406 int start_line
= (locator
->line_no
-
407 (win_info
->viewport_height
/ 2)) + 1;
411 struct tui_line_or_address l
;
414 l
.u
.line_no
= start_line
;
415 if (!(source_already_displayed
416 && tui_line_is_displayed (locator
->line_no
,
418 tui_update_source_window (win_info
, get_frame_arch (fi
),
419 sal
.symtab
, l
, TRUE
);
422 l
.u
.line_no
= locator
->line_no
;
423 win_info
->set_is_exec_point_at (l
);
430 if (find_pc_partial_function (get_frame_pc (fi
),
431 NULL
, &low
, NULL
) == 0)
433 /* There is no symbol available for current PC. There is no
434 safe way how to "disassemble backwards". */
435 low
= get_frame_pc (fi
);
438 low
= tui_get_low_disassembly_address (get_frame_arch (fi
),
439 low
, get_frame_pc (fi
));
441 struct tui_line_or_address a
;
445 if (!tui_addr_is_displayed (locator
->addr
,
447 tui_update_source_window (win_info
, get_frame_arch (fi
),
448 sal
.symtab
, a
, TRUE
);
451 a
.u
.addr
= locator
->addr
;
452 win_info
->set_is_exec_point_at (a
);
456 win_info
->update_exec_info ();
464 = tui_set_locator_info (NULL
, NULL
, NULL
, 0, (CORE_ADDR
) 0);
466 if (!locator_changed_p
)
469 tui_show_locator_content ();
470 for (struct tui_source_window_base
*win_info
: tui_source_windows ())
472 tui_clear_source_content (win_info
);
473 win_info
->update_exec_info ();
480 /* Function to initialize gdb commands, for tui window stack
484 _initialize_tui_stack (void)
486 add_com ("update", class_tui
, tui_update_command
,
487 _("Update the source window and locator to "
488 "display the current execution point."));
491 /* Command to update the display with the current execution point. */
493 tui_update_command (const char *arg
, int from_tty
)
495 execute_command ("frame 0", from_tty
);