GDB (xrefs)

tui-stack.c
Go to the documentation of this file.
1 /* TUI display locator.
2
3 Copyright (C) 1998-2018 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 (const 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*
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 int target_width;
72 int pid_width;
73 int line_width;
74
75 if (ptid_equal (inferior_ptid, null_ptid))
76 pid_name = "No process";
77 else
78 pid_name = target_pid_to_str (inferior_ptid);
79
80 target_width = strlen (target_shortname);
81 if (target_width > MAX_TARGET_WIDTH)
82 target_width = MAX_TARGET_WIDTH;
83
84 pid_width = strlen (pid_name);
85 if (pid_width > MAX_PID_WIDTH)
86 pid_width = MAX_PID_WIDTH;
87
88 status_size = tui_term_width ();
89 string = (char *) xmalloc (status_size + 1);
90 buf = (char*) alloca (status_size + 1);
91
92 /* Translate line number and obtain its size. */
93 if (loc->line_no > 0)
94 xsnprintf (line_buf, sizeof (line_buf), "%d", loc->line_no);
95 else
96 strcpy (line_buf, "??");
97 line_width = strlen (line_buf);
98 if (line_width < MIN_LINE_WIDTH)
99 line_width = MIN_LINE_WIDTH;
100
101 /* Translate PC address. */
102 string_file pc_out;
103
104 fputs_filtered (loc->gdbarch? paddress (loc->gdbarch, loc->addr) : "??",
105 &pc_out);
106
107 const char *pc_buf = pc_out.c_str ();
108 int pc_width = pc_out.size ();
109
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
114 - (target_width + 1)
115 - (pid_width + 1)
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)
121 : 0));
122
123 /* If there is no room to print the function name, try by removing
124 some fields. */
125 if (proc_width < MIN_PROC_WIDTH)
126 {
127 proc_width += target_width + 1;
128 target_width = 0;
129 if (proc_width < MIN_PROC_WIDTH)
130 {
131 proc_width += pid_width + 1;
132 pid_width = 0;
133 if (proc_width <= MIN_PROC_WIDTH)
134 {
135 proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
136 pc_width = 0;
137 if (proc_width < 0)
138 {
139 proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
140 line_width = 0;
141 if (proc_width < 0)
142 proc_width = 0;
143 }
144 }
145 }
146 }
147
148 /* Now convert elements to string form. */
149 pname = loc->proc_name;
150
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. */
155 *string = (char) 0;
156
157 if (target_width > 0)
158 {
159 sprintf (buf, "%*.*s ",
160 -target_width, target_width, target_shortname);
161 strcat_to_buf (string, status_size, buf);
162 }
163 if (pid_width > 0)
164 {
165 sprintf (buf, "%*.*s ",
166 -pid_width, pid_width, pid_name);
167 strcat_to_buf (string, status_size, buf);
168 }
169
170 /* Show whether we are in SingleKey mode. */
171 if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
172 {
173 strcat_to_buf (string, status_size, SINGLE_KEY);
174 strcat_to_buf (string, status_size, " ");
175 }
176
177 /* Procedure/class name. */
178 if (proc_width > 0)
179 {
180 if (strlen (pname) > proc_width)
181 sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
182 1 - proc_width, proc_width - 1, pname);
183 else
184 sprintf (buf, "%s%*.*s ", PROC_PREFIX,
185 -proc_width, proc_width, pname);
186 strcat_to_buf (string, status_size, buf);
187 }
188
189 if (line_width > 0)
190 {
191 sprintf (buf, "%s%*.*s ", LINE_PREFIX,
192 -line_width, line_width, line_buf);
193 strcat_to_buf (string, status_size, buf);
194 }
195 if (pc_width > 0)
196 {
197 strcat_to_buf (string, status_size, PC_PREFIX);
198 strcat_to_buf (string, status_size, pc_buf);
199 }
200
201
202 for (i = strlen (string); i < status_size; i++)
203 string[i] = ' ';
204 string[status_size] = (char) 0;
205
206 return string;
207 }
208
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. */
212 static char*
213 tui_get_function_from_frame (struct frame_info *fi)
214 {
215 static char name[256];
216 string_file stream;
217
218 print_address_symbolic (get_frame_arch (fi), get_frame_pc (fi),
219 &stream, demangle, "");
220
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 ();
225 if (*d == '<')
226 d++;
227 strncpy (name, d, sizeof (name) - 1);
228 name[sizeof (name) - 1] = 0;
229
230 char *p = strchr (name, '(');
231 if (!p)
232 p = strchr (name, '>');
233 if (p)
234 *p = 0;
235 p = strchr (name, '+');
236 if (p)
237 *p = 0;
238 return name;
239 }
240
241 void
242 tui_show_locator_content (void)
243 {
244 char *string;
245 struct tui_gen_win_info *locator;
246
247 locator = tui_locator_win_info_ptr ();
248
249 if (locator != NULL && locator->handle != (WINDOW *) NULL)
250 {
251 struct tui_win_element *element;
252
253 element = locator->content[0];
254
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);
268 xfree (string);
269 locator->content_in_use = TRUE;
270 }
271 }
272
273
274 /* Set the filename portion of the locator. */
275 static void
276 tui_set_locator_fullname (const char *fullname)
277 {
278 struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
279 struct tui_locator_element *element;
280
281 if (locator->content[0] == NULL)
282 {
283 tui_set_locator_info (NULL, fullname, NULL, 0, 0);
284 return;
285 }
286
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);
290 }
291
292 /* Update the locator, with the provided arguments.
293
294 Returns 1 if any of the locator's fields were actually changed,
295 and 0 otherwise. */
296
297 static int
298 tui_set_locator_info (struct gdbarch *gdbarch,
299 const char *fullname,
300 const char *procname,
301 int lineno,
302 CORE_ADDR addr)
303 {
304 struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
305 struct tui_locator_element *element;
306 int locator_changed_p = 0;
307
308 /* Allocate the locator content if necessary. */
309 if (locator->content_size <= 0)
310 {
311 locator->content = tui_alloc_content (1, LOCATOR_WIN);
312 locator->content_size = 1;
313 locator_changed_p = 1;
314 }
315
316 if (procname == NULL)
317 procname = "";
318
319 if (fullname == NULL)
320 fullname = "";
321
322 element = &locator->content[0]->which_element.locator;
323
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;
331
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);
338
339 return locator_changed_p;
340 }
341
342 /* Update only the full_name portion of the locator. */
343 void
344 tui_update_locator_fullname (const char *fullname)
345 {
346 tui_set_locator_fullname (fullname);
347 tui_show_locator_content ();
348 }
349
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.
352
353 Return 1 if frame information has changed (and windows subsequently
354 refreshed), 0 otherwise. */
355
356 int
357 tui_show_frame_info (struct frame_info *fi)
358 {
359 struct tui_win_info *win_info;
360 int locator_changed_p;
361 int i;
362
363 if (fi)
364 {
365 int start_line, i;
366 CORE_ADDR low;
367 struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
368 int source_already_displayed;
369 CORE_ADDR pc;
370
371 symtab_and_line sal = find_frame_sal (fi);
372
373 source_already_displayed = sal.symtab != 0
374 && tui_source_is_displayed (symtab_to_fullname (sal.symtab));
375
376 if (get_frame_pc_if_available (fi, &pc))
377 locator_changed_p
378 = tui_set_locator_info (get_frame_arch (fi),
379 (sal.symtab == 0
380 ? "??" : symtab_to_fullname (sal.symtab)),
381 tui_get_function_from_frame (fi),
382 sal.line,
383 pc);
384 else
385 locator_changed_p
386 = tui_set_locator_info (get_frame_arch (fi),
387 "??", _("<unavailable>"), sal.line, 0);
388
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)
393 return 0;
394
395 tui_show_locator_content ();
396 start_line = 0;
397 for (i = 0; i < (tui_source_windows ())->count; i++)
398 {
399 union tui_which_element *item;
400
401 win_info = (tui_source_windows ())->list[i];
402
403 item = &locator->content[0]->which_element;
404 if (win_info == TUI_SRC_WIN)
405 {
406 start_line = (item->locator.line_no -
407 (win_info->generic.viewport_height / 2)) + 1;
408 if (start_line <= 0)
409 start_line = 1;
410 }
411 else
412 {
413 if (find_pc_partial_function (get_frame_pc (fi),
414 (const char **) NULL,
415 &low, NULL) == 0)
416 {
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);
420 }
421 else
422 low = tui_get_low_disassembly_address (get_frame_arch (fi),
423 low, get_frame_pc (fi));
424 }
425
426 if (win_info == TUI_SRC_WIN)
427 {
428 struct tui_line_or_address l;
429
430 l.loa = LOA_LINE;
431 l.u.line_no = start_line;
432 if (!(source_already_displayed
433 && tui_line_is_displayed (item->locator.line_no,
434 win_info, TRUE)))
435 tui_update_source_window (win_info, get_frame_arch (fi),
436 sal.symtab, l, TRUE);
437 else
438 {
439 l.u.line_no = item->locator.line_no;
440 tui_set_is_exec_point_at (l, win_info);
441 }
442 }
443 else
444 {
445 if (win_info == TUI_DISASM_WIN)
446 {
447 struct tui_line_or_address a;
448
449 a.loa = LOA_ADDRESS;
450 a.u.addr = low;
451 if (!tui_addr_is_displayed (item->locator.addr,
452 win_info, TRUE))
453 tui_update_source_window (win_info, get_frame_arch (fi),
454 sal.symtab, a, TRUE);
455 else
456 {
457 a.u.addr = item->locator.addr;
458 tui_set_is_exec_point_at (a, win_info);
459 }
460 }
461 }
462 tui_update_exec_info (win_info);
463 }
464
465 return 1;
466 }
467 else
468 {
469 locator_changed_p
470 = tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
471
472 if (!locator_changed_p)
473 return 0;
474
475 tui_show_locator_content ();
476 for (i = 0; i < (tui_source_windows ())->count; i++)
477 {
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);
481 }
482
483 return 1;
484 }
485 }
486
487 /* Function to initialize gdb commands, for tui window stack
488 manipulation. */
489
490 void
491 _initialize_tui_stack (void)
492 {
493 add_com ("update", class_tui, tui_update_command,
494 _("Update the source window and locator to "
495 "display the current execution point.\n"));
496 }
497
498 /* Command to update the display with the current execution point. */
499 static void
500 tui_update_command (const char *arg, int from_tty)
501 {
502 execute_command ("frame 0", from_tty);
503 }
MIN_LINE_WIDTH
#define MIN_LINE_WIDTH
Definition: tui-data.h:89
gdbarch
Definition: gdbarch.c:127
top.h
string
const char * string
Definition: signals.c:50
extract_bp_kind::loc
demangle
int demangle
Definition: demangle.c:47
tui_gen_win_info::content
tui_win_content content
Definition: tui-data.h:47
tui_gen_win_info
Definition: tui-data.h:40
tui-stack.h
tui_line_or_address
Definition: tui-data.h:140
tui_gen_win_info::viewport_height
int viewport_height
Definition: tui-data.h:50
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
tui_gen_win_info::content_size
int content_size
Definition: tui-data.h:48
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
target_shortname
#define target_shortname
Definition: target.h:1279
command.h
xfree
void xfree(void *)
tui_get_function_from_frame
static char * tui_get_function_from_frame(struct frame_info *fi)
Definition: tui-stack.c:213
get_frame_pc_if_available
int get_frame_pc_if_available(struct frame_info *frame, CORE_ADDR *pc)
Definition: frame.c:2383
MIN_PROC_WIDTH
#define MIN_PROC_WIDTH
Definition: tui-data.h:91
tui_source_windows
struct tui_list * tui_source_windows(void)
Definition: tui-data.c:159
tui_source_is_displayed
int tui_source_is_displayed(const char *fullname)
Definition: tui-source.c:335
tui_update_exec_info
void tui_update_exec_info(struct tui_win_info *win_info)
Definition: tui-winsource.c:595
frame_info
Definition: frame.c:85
tui_set_locator_fullname
static void tui_set_locator_fullname(const char *fullname)
Definition: tui-stack.c:276
tui_set_is_exec_point_at
void tui_set_is_exec_point_at(struct tui_line_or_address l, struct tui_win_info *win_info)
Definition: tui-winsource.c:362
_
#define _(String)
Definition: gdb_locale.h:35
defs.h
tui_gen_win_info::handle
WINDOW * handle
Definition: tui-data.h:42
LINE_PREFIX
#define LINE_PREFIX
Definition: tui-data.h:83
tui_line_or_address::loa
enum tui_line_or_address_kind loa
Definition: tui-data.h:142
tui_update_locator_fullname
void tui_update_locator_fullname(const char *fullname)
Definition: tui-stack.c:344
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
tui_win_element
Definition: tui-data.h:230
execute_command
void execute_command(const char *, int)
Definition: top.c:540
symtab_to_fullname
const char * symtab_to_fullname(struct symtab *s)
Definition: source.c:1131
tui_update_source_window
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
tui_locator_element::full_name
char full_name[MAX_LOCATOR_ELEMENT_LEN]
Definition: tui-data.h:196
symtab.h
class_tui
Definition: command.h:44
name
const char *const name
Definition: aarch64-tdep.c:76
tui_which_element::locator
struct tui_locator_element locator
Definition: tui-data.h:226
tui_set_locator_info
static int tui_set_locator_info(struct gdbarch *gdbarch, const char *fullname, const char *procname, int lineno, CORE_ADDR addr)
Definition: tui-stack.c:298
LOCATOR_WIN
Definition: tui.h:46
tui_win_info::generic
struct tui_gen_win_info generic
Definition: tui-data.h:275
tui-source.h
tui_locator_element::line_no
int line_no
Definition: tui-data.h:198
tui_alloc_content
tui_win_content tui_alloc_content(int num_elements, enum tui_win_type type)
Definition: tui-data.c:573
tui_locator_element::addr
CORE_ADDR addr
Definition: tui-data.h:199
tui-winsource.h
strcat_to_buf
void strcat_to_buf(char *buf, int buflen, const char *item_to_add)
Definition: tui.c:562
tui_clear_source_content
void tui_clear_source_content(struct tui_win_info *win_info, int display_prompt)
Definition: tui-winsource.c:210
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
frame.h
inferior.h
tui_locator_win_info_ptr
struct tui_gen_win_info * tui_locator_win_info_ptr(void)
Definition: tui-data.c:253
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
tui_win_info
Definition: tui-data.h:273
MAX_TARGET_WIDTH
#define MAX_TARGET_WIDTH
Definition: tui-data.h:92
tui_addr_is_displayed
int tui_addr_is_displayed(CORE_ADDR addr, struct tui_win_info *win_info, int check_threshold)
Definition: tui-winsource.c:665
tui_line_or_address::line_no
int line_no
Definition: tui-data.h:145
string_file::size
size_t size() const
Definition: ui-file.h:138
MAX_PID_WIDTH
#define MAX_PID_WIDTH
Definition: tui-data.h:93
LOA_ADDRESS
Definition: tui-data.h:136
breakpoint.h
xmalloc
void * xmalloc(YYSIZE_T)
symtab_and_line::symtab
struct symtab * symtab
Definition: symtab.h:1751
tui-wingeneral.h
find_frame_sal
symtab_and_line find_frame_sal(frame_info *frame)
Definition: frame.c:2487
tui_locator_element::gdbarch
struct gdbarch * gdbarch
Definition: tui-data.h:201
tui_make_status_line
static char * tui_make_status_line(struct tui_locator_element *loc)
Definition: tui-stack.c:63
tui_show_locator_content
void tui_show_locator_content(void)
Definition: tui-stack.c:242
symtab_and_line
Definition: symtab.h:1746
tui_win_element::which_element
union tui_which_element which_element
Definition: tui-data.h:233
tui_gen_win_info::content_in_use
int content_in_use
Definition: tui-data.h:49
TUI_SRC_WIN
#define TUI_SRC_WIN
Definition: tui-data.h:298
null_ptid
ptid_t null_ptid
Definition: ptid.c:25
source.h
LOA_LINE
Definition: tui-data.h:135
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
string_file::c_str
const char * c_str() const
Definition: ui-file.h:137
inferior_ptid
ptid_t inferior_ptid
Definition: infcmd.c:94
tui_update_command
static void tui_update_command(const char *, int)
Definition: tui-stack.c:500
tui_line_or_address::u
union tui_line_or_address::@181 u
target_pid_to_str
const char * target_pid_to_str(ptid_t ptid)
Definition: target.c:2194
tui_term_width
int tui_term_width(void)
Definition: tui-data.c:277
MAX_LOCATOR_ELEMENT_LEN
#define MAX_LOCATOR_ELEMENT_LEN
Definition: tui-data.h:189
tui-data.h
tui_locator_element
Definition: tui-data.h:193
tui.h
gdb_curses.h
target.h
tui_which_element
Definition: tui-data.h:220
SINGLE_KEY
#define SINGLE_KEY
Definition: tui-data.h:85
TUI_DISASM_WIN
#define TUI_DISASM_WIN
Definition: tui-data.h:299
ptid_equal
int ptid_equal(const ptid_t &ptid1, const ptid_t &ptid2)
Definition: ptid.c:71
PROC_PREFIX
#define PROC_PREFIX
Definition: tui-data.h:82
tui_show_frame_info
int tui_show_frame_info(struct frame_info *fi)
Definition: tui-stack.c:357
EMPTY_SOURCE_PROMPT
#define EMPTY_SOURCE_PROMPT
Definition: tui-data.h:75
print_address_symbolic
int print_address_symbolic(struct gdbarch *, CORE_ADDR, struct ui_file *, int, const char *)
Definition: printcmd.c:521
tui_refresh_win
void tui_refresh_win(struct tui_gen_win_info *win_info)
Definition: tui-wingeneral.c:36
symtab_and_line::line
int line
Definition: symtab.h:1757
_initialize_tui_stack
void _initialize_tui_stack(void)
Definition: tui-stack.c:491
add_com
struct cmd_list_element * add_com(const char *name, enum command_class theclass, cmd_const_cfunc_ftype *fun, const char *doc)
Definition: cli-decode.c:902
tui_current_key_mode
enum tui_key_mode tui_current_key_mode
Definition: tui.c:63
tui_line_or_address::addr
CORE_ADDR addr
Definition: tui-data.h:146
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
tui_locator_element::proc_name
char proc_name[MAX_LOCATOR_ELEMENT_LEN]
Definition: tui-data.h:197
TUI_SINGLE_KEY_MODE
Definition: tui.h:79
gdb-demangle.h
tui-file.h
tui_line_is_displayed
int tui_line_is_displayed(int line, struct tui_win_info *win_info, int check_threshold)
Definition: tui-winsource.c:635
tui_get_low_disassembly_address
CORE_ADDR tui_get_low_disassembly_address(struct gdbarch *gdbarch, CORE_ADDR low, CORE_ADDR pc)
Definition: tui-disasm.c:359
PC_PREFIX
#define PC_PREFIX
Definition: tui-data.h:84
string_file
Definition: ui-file.h:106