GDB (xrefs)
tui-winsource.c
Go to the documentation of this file.
1 /* TUI display source/assembly window.
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 <ctype.h>
24 #include "symtab.h"
25 #include "frame.h"
26 #include "breakpoint.h"
27 #include "value.h"
28 #include "source.h"
29 #include "objfiles.h"
30 #include "filenames.h"
31 
32 #include "tui/tui.h"
33 #include "tui/tui-data.h"
34 #include "tui/tui-stack.h"
35 #include "tui/tui-win.h"
36 #include "tui/tui-wingeneral.h"
37 #include "tui/tui-winsource.h"
38 #include "tui/tui-source.h"
39 #include "tui/tui-disasm.h"
40 #include "gdb_curses.h"
41 
42 /* Function to display the "main" routine. */
43 void
45 {
46  if ((tui_source_windows ())->count > 0)
47  {
48  struct gdbarch *gdbarch;
49  CORE_ADDR addr;
50 
51  tui_get_begin_asm_address (&gdbarch, &addr);
52  if (addr != (CORE_ADDR) 0)
53  {
54  struct symtab *s;
55 
57  s = find_pc_line_symtab (addr);
58  if (s != NULL)
60  else
62  }
63  }
64 }
65 
66 
67 
68 /* Function to display source in the source window. This function
69  initializes the horizontal scroll to 0. */
70 void
72  struct gdbarch *gdbarch,
73  struct symtab *s,
74  struct tui_line_or_address line_or_addr,
75  int noerror)
76 {
77  win_info->detail.source_info.horizontal_offset = 0;
78  tui_update_source_window_as_is (win_info, gdbarch, s, line_or_addr, noerror);
79 
80  return;
81 }
82 
83 
84 /* Function to display source in the source/asm window. This function
85  shows the source as specified by the horizontal offset. */
86 void
88  struct gdbarch *gdbarch,
89  struct symtab *s,
90  struct tui_line_or_address line_or_addr,
91  int noerror)
92 {
93  enum tui_status ret;
94 
95  if (win_info->generic.type == SRC_WIN)
96  ret = tui_set_source_content (s, line_or_addr.u.line_no, noerror);
97  else
98  ret = tui_set_disassem_content (gdbarch, line_or_addr.u.addr);
99 
100  if (ret == TUI_FAILURE)
101  {
103  tui_clear_exec_info_content (win_info);
104  }
105  else
106  {
107  tui_update_breakpoint_info (win_info, 0);
108  tui_show_source_content (win_info);
109  tui_update_exec_info (win_info);
110  if (win_info->generic.type == SRC_WIN)
111  {
112  struct symtab_and_line sal;
113 
114  init_sal (&sal);
115  sal.line = line_or_addr.u.line_no +
116  (win_info->generic.content_size - 2);
117  sal.symtab = s;
118  sal.pspace = SYMTAB_PSPACE (s);
120  /* If the focus was in the asm win, put it in the src win if
121  we don't have a split layout. */
125  }
126  }
127 
128 
129  return;
130 }
131 
132 
133 /* Function to ensure that the source and/or disassemly windows
134  reflect the input address. */
135 void
137 {
138  if (addr != 0)
139  {
140  struct symtab_and_line sal;
141  struct tui_line_or_address l;
142 
143  switch (tui_current_layout ())
144  {
145  case DISASSEM_COMMAND:
147  tui_show_disassem (gdbarch, addr);
148  break;
150  tui_show_disassem_and_update_source (gdbarch, addr);
151  break;
152  default:
153  sal = find_pc_line (addr, 0);
154  l.loa = LOA_LINE;
155  l.u.line_no = sal.line;
156  tui_show_symtab_source (gdbarch, sal.symtab, l, FALSE);
157  break;
158  }
159  }
160  else
161  {
162  int i;
163 
164  for (i = 0; i < (tui_source_windows ())->count; i++)
165  {
166  struct tui_win_info *win_info = (tui_source_windows ())->list[i];
167 
169  tui_clear_exec_info_content (win_info);
170  }
171  }
172 }
173 
174 /* Function to ensure that the source and/or disassemly windows
175  reflect the input address. */
176 void
178 {
179  struct gdbarch *gdbarch;
180  CORE_ADDR pc;
181  struct tui_line_or_address l;
182 
183  if (!s)
184  return;
185 
186  gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
187 
188  switch (tui_current_layout ())
189  {
190  case DISASSEM_COMMAND:
192  find_line_pc (s, line, &pc);
194  break;
195  default:
196  l.loa = LOA_LINE;
197  l.u.line_no = line;
198  tui_show_symtab_source (gdbarch, s, l, FALSE);
200  {
201  find_line_pc (s, line, &pc);
202  tui_show_disassem (gdbarch, pc);
203  }
204  break;
205  }
206 
207  return;
208 }
209 
210 void
212  int display_prompt)
213 {
214  if (win_info != NULL)
215  {
216  int i;
217 
218  win_info->generic.content_in_use = FALSE;
219  tui_erase_source_content (win_info, display_prompt);
220  for (i = 0; i < win_info->generic.content_size; i++)
221  {
222  struct tui_win_element *element = win_info->generic.content[i];
223 
224  element->which_element.source.has_break = FALSE;
225  element->which_element.source.is_exec_point = FALSE;
226  }
227  }
228 }
229 
230 
231 void
233  int display_prompt)
234 {
235  int x_pos;
236  int half_width = (win_info->generic.width - 2) / 2;
237 
238  if (win_info->generic.handle != (WINDOW *) NULL)
239  {
240  werase (win_info->generic.handle);
242  if (display_prompt == EMPTY_SOURCE_PROMPT)
243  {
244  char *no_src_str;
245 
246  if (win_info->generic.type == SRC_WIN)
247  no_src_str = NO_SRC_STRING;
248  else
249  no_src_str = NO_DISASSEM_STRING;
250  if (strlen (no_src_str) >= half_width)
251  x_pos = 1;
252  else
253  x_pos = half_width - strlen (no_src_str);
254  mvwaddstr (win_info->generic.handle,
255  (win_info->generic.height / 2),
256  x_pos,
257  no_src_str);
258 
259  /* elz: Added this function call to set the real contents of
260  the window to what is on the screen, so that later calls
261  to refresh, do display the correct stuff, and not the old
262  image. */
263 
264  tui_set_source_content_nil (win_info, no_src_str);
265  }
266  tui_refresh_win (&win_info->generic);
267  }
268 }
269 
270 
271 /* Redraw the complete line of a source or disassembly window. */
272 static void
273 tui_show_source_line (struct tui_win_info *win_info, int lineno)
274 {
275  struct tui_win_element *line;
276  int x, y;
277 
278  line = win_info->generic.content[lineno - 1];
280  wattron (win_info->generic.handle, A_STANDOUT);
281 
282  mvwaddstr (win_info->generic.handle, lineno, 1,
283  line->which_element.source.line);
285  wattroff (win_info->generic.handle, A_STANDOUT);
286 
287  /* Clear to end of line but stop before the border. */
288  getyx (win_info->generic.handle, y, x);
289  while (x + 1 < win_info->generic.width)
290  {
291  waddch (win_info->generic.handle, ' ');
292  getyx (win_info->generic.handle, y, x);
293  }
294 }
295 
296 void
298 {
299  if (win_info->generic.content_size > 0)
300  {
301  int lineno;
302 
303  for (lineno = 1; lineno <= win_info->generic.content_size; lineno++)
304  tui_show_source_line (win_info, lineno);
305  }
306  else
307  tui_erase_source_content (win_info, TRUE);
308 
310  tui_refresh_win (&win_info->generic);
311  win_info->generic.content_in_use = TRUE;
312 }
313 
314 
315 /* Scroll the source forward or backward horizontally. */
316 void
318  enum tui_scroll_direction direction,
319  int num_to_scroll)
320 {
321  if (win_info->generic.content != NULL)
322  {
323  struct gdbarch *gdbarch = win_info->detail.source_info.gdbarch;
324  int offset;
325  struct symtab *s = NULL;
326 
327  if (win_info->generic.type == SRC_WIN)
328  {
329  struct symtab_and_line cursal
331 
332  if (cursal.symtab == NULL)
334  else
335  s = cursal.symtab;
336  }
337 
338  if (direction == LEFT_SCROLL)
339  offset = win_info->detail.source_info.horizontal_offset
340  + num_to_scroll;
341  else
342  {
343  offset = win_info->detail.source_info.horizontal_offset
344  - num_to_scroll;
345  if (offset < 0)
346  offset = 0;
347  }
349  tui_update_source_window_as_is (win_info, gdbarch, s,
350  win_info->generic.content[0]
352  FALSE);
353  }
354 
355  return;
356 }
357 
358 
359 /* Set or clear the has_break flag in the line whose line is
360  line_no. */
361 
362 void
364  struct tui_win_info *win_info)
365 {
366  int changed = 0;
367  int i;
368  tui_win_content content = (tui_win_content) win_info->generic.content;
369 
370  i = 0;
371  while (i < win_info->generic.content_size)
372  {
373  int new_state;
374  struct tui_line_or_address content_loa =
375  content[i]->which_element.source.line_or_addr;
376 
377  gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
378  gdb_assert (content_loa.loa == LOA_LINE
379  || content_loa.loa == LOA_ADDRESS);
380  if (content_loa.loa == l.loa
381  && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
382  || (content_loa.u.addr == l.u.addr)))
383  new_state = TRUE;
384  else
385  new_state = FALSE;
386  if (new_state != content[i]->which_element.source.is_exec_point)
387  {
388  changed++;
389  content[i]->which_element.source.is_exec_point = new_state;
390  tui_show_source_line (win_info, i + 1);
391  }
392  i++;
393  }
394  if (changed)
395  tui_refresh_win (&win_info->generic);
396 }
397 
398 /* Update the execution windows to show the active breakpoints.
399  This is called whenever a breakpoint is inserted, removed or
400  has its state changed. */
401 void
403 {
404  struct tui_list *list = tui_source_windows ();
405  int i;
406 
407  for (i = 0; i < list->count; i++)
408  {
409  struct tui_win_info *win = list->list[i];
410 
411  if (tui_update_breakpoint_info (win, FALSE))
412  {
413  tui_update_exec_info (win);
414  }
415  }
416 }
417 
418 
419 /* Scan the source window and the breakpoints to update the has_break
420  information for each line.
421 
422  Returns 1 if something changed and the execution window must be
423  refreshed. */
424 
425 int
427  int current_only)
428 {
429  int i;
430  int need_refresh = 0;
431  struct tui_source_info *src = &win->detail.source_info;
432 
433  for (i = 0; i < win->generic.content_size; i++)
434  {
435  struct breakpoint *bp;
436  extern struct breakpoint *breakpoint_chain;
437  int mode;
438  struct tui_source_element *line;
439 
440  line = &win->generic.content[i]->which_element.source;
441  if (current_only && !line->is_exec_point)
442  continue;
443 
444  /* Scan each breakpoint to see if the current line has something to
445  do with it. Identify enable/disabled breakpoints as well as
446  those that we already hit. */
447  mode = 0;
448  for (bp = breakpoint_chain;
449  bp != (struct breakpoint *) NULL;
450  bp = bp->next)
451  {
452  struct bp_location *loc;
453 
455  || line->line_or_addr.loa == LOA_ADDRESS);
456 
457  for (loc = bp->loc; loc != NULL; loc = loc->next)
458  {
459  if ((win == TUI_SRC_WIN
460  && loc->symtab != NULL
461  && filename_cmp (src->fullname,
462  symtab_to_fullname (loc->symtab)) == 0
463  && line->line_or_addr.loa == LOA_LINE
464  && loc->line_number == line->line_or_addr.u.line_no)
465  || (win == TUI_DISASM_WIN
466  && line->line_or_addr.loa == LOA_ADDRESS
467  && loc->address == line->line_or_addr.u.addr))
468  {
469  if (bp->enable_state == bp_disabled)
470  mode |= TUI_BP_DISABLED;
471  else
472  mode |= TUI_BP_ENABLED;
473  if (bp->hit_count)
474  mode |= TUI_BP_HIT;
475  if (bp->loc->cond)
476  mode |= TUI_BP_CONDITIONAL;
477  if (bp->type == bp_hardware_breakpoint)
478  mode |= TUI_BP_HARDWARE;
479  }
480  }
481  }
482  if (line->has_break != mode)
483  {
484  line->has_break = mode;
485  need_refresh = 1;
486  }
487  }
488  return need_refresh;
489 }
490 
491 
492 /* Function to initialize the content of the execution info window,
493  based upon the input window which is either the source or
494  disassembly window. */
495 enum tui_status
497 {
498  enum tui_status ret = TUI_SUCCESS;
499 
500  if (win_info->detail.source_info.execution_info
501  != (struct tui_gen_win_info *) NULL)
502  {
503  struct tui_gen_win_info *exec_info_ptr
504  = win_info->detail.source_info.execution_info;
505 
506  if (exec_info_ptr->content == NULL)
507  exec_info_ptr->content =
508  tui_alloc_content (win_info->generic.height, exec_info_ptr->type);
509  if (exec_info_ptr->content != NULL)
510  {
511  int i;
512 
513  tui_update_breakpoint_info (win_info, 1);
514  for (i = 0; i < win_info->generic.content_size; i++)
515  {
516  struct tui_win_element *element;
517  struct tui_win_element *src_element;
518  int mode;
519 
520  element = exec_info_ptr->content[i];
521  src_element = win_info->generic.content[i];
522 
523  memset(element->which_element.simple_string, ' ',
524  sizeof(element->which_element.simple_string));
526 
527  /* Now update the exec info content based upon the state
528  of each line as indicated by the source content. */
529  mode = src_element->which_element.source.has_break;
530  if (mode & TUI_BP_HIT)
532  (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
533  else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
535  (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
536 
537  if (mode & TUI_BP_ENABLED)
539  else if (mode & TUI_BP_DISABLED)
541 
542  if (src_element->which_element.source.is_exec_point)
543  element->which_element.simple_string[TUI_EXEC_POS] = '>';
544  }
545  exec_info_ptr->content_size = win_info->generic.content_size;
546  }
547  else
548  ret = TUI_FAILURE;
549  }
550 
551  return ret;
552 }
553 
554 
555 void
557 {
559  = win_info->detail.source_info.execution_info;
560  int cur_line;
561 
562  werase (exec_info->handle);
563  tui_refresh_win (exec_info);
564  for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
565  mvwaddstr (exec_info->handle,
566  cur_line,
567  0,
568  exec_info->content[cur_line - 1]->which_element.simple_string);
569  tui_refresh_win (exec_info);
570  exec_info->content_in_use = TRUE;
571 }
572 
573 
574 void
576 {
578  = win_info->detail.source_info.execution_info;
579 
580  werase (exec_info->handle);
581  tui_refresh_win (exec_info);
582 }
583 
584 void
586 {
587  win_info->detail.source_info.execution_info->content_in_use = FALSE;
588  tui_erase_exec_info_content (win_info);
589 
590  return;
591 }
592 
593 /* Function to update the execution info window. */
594 void
596 {
597  tui_set_exec_info_content (win_info);
598  tui_show_exec_info_content (win_info);
599 }
600 
601 enum tui_status
603 {
604  char *src_line_buf;
605  int i, line_width, max_lines;
606 
607  max_lines = win_info->generic.height; /* Less the highlight box. */
608  line_width = win_info->generic.width - 1;
609  /*
610  * Allocate the buffer for the source lines. Do this only once
611  * since they will be re-used for all source displays. The only
612  * other time this will be done is when a window's size changes.
613  */
614  if (win_info->generic.content == NULL)
615  {
616  src_line_buf = (char *)
617  xmalloc ((max_lines * line_width) * sizeof (char));
618  if (src_line_buf == (char *) NULL)
619  {
620  fputs_unfiltered ("Unable to Allocate Memory for "
621  "Source or Disassembly Display.\n",
622  gdb_stderr);
623  return TUI_FAILURE;
624  }
625  /* Allocate the content list. */
626  win_info->generic.content = tui_alloc_content (max_lines, SRC_WIN);
627  if (win_info->generic.content == NULL)
628  {
629  xfree (src_line_buf);
630  fputs_unfiltered ("Unable to Allocate Memory for "
631  "Source or Disassembly Display.\n",
632  gdb_stderr);
633  return TUI_FAILURE;
634  }
635  for (i = 0; i < max_lines; i++)
636  win_info->generic.content[i]->which_element.source.line
637  = src_line_buf + (line_width * i);
638  }
639 
640  return TUI_SUCCESS;
641 }
642 
643 
644 /* Answer whether a particular line number or address is displayed
645  in the current source window. */
646 int
648  struct tui_win_info *win_info,
649  int check_threshold)
650 {
651  int is_displayed = FALSE;
652  int i, threshold;
653 
654  if (check_threshold)
655  threshold = SCROLL_THRESHOLD;
656  else
657  threshold = 0;
658  i = 0;
659  while (i < win_info->generic.content_size - threshold
660  && !is_displayed)
661  {
662  is_displayed
663  = win_info->generic.content[i]
665  && win_info->generic.content[i]
667  i++;
668  }
669 
670  return is_displayed;
671 }
672 
673 
674 /* Answer whether a particular line number or address is displayed
675  in the current source window. */
676 int
678  struct tui_win_info *win_info,
679  int check_threshold)
680 {
681  int is_displayed = FALSE;
682  int i, threshold;
683 
684  if (check_threshold)
685  threshold = SCROLL_THRESHOLD;
686  else
687  threshold = 0;
688  i = 0;
689  while (i < win_info->generic.content_size - threshold
690  && !is_displayed)
691  {
692  is_displayed
693  = win_info->generic.content[i]
695  && win_info->generic.content[i]
697  i++;
698  }
699 
700  return is_displayed;
701 }
702 
703 
704 /*****************************************
705 ** STATIC LOCAL FUNCTIONS **
706 ******************************************/
int horizontal_offset
Definition: tui-data.h:255
#define TUI_BP_HIT
Definition: tui-data.h:207
void tui_get_begin_asm_address(struct gdbarch **gdbarch_p, CORE_ADDR *addr_p)
Definition: tui-disasm.c:328
int line_number
Definition: breakpoint.h:466
tui_win_content content
Definition: tui-data.h:47
enum tui_status tui_set_source_content(struct symtab *s, int line_no, int noerror)
Definition: tui-source.c:41
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
enum tui_win_type type
Definition: tui-data.h:43
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
bfd_vma CORE_ADDR
Definition: common-types.h:41
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
#define TUI_EXECINFO_SIZE
Definition: tui-data.h:215
void xfree(void *)
Definition: common-utils.c:97
int tui_update_breakpoint_info(struct tui_win_info *win, int current_only)
tui_exec_info_content simple_string
Definition: tui-data.h:227
struct symtab * symtab
Definition: breakpoint.h:471
struct tui_line_or_address line_or_addr
Definition: tui-data.h:161
struct symtab_and_line get_current_source_symtab_and_line(void)
Definition: source.c:181
void tui_horizontal_source_scroll(struct tui_win_info *win_info, enum tui_scroll_direction direction, int num_to_scroll)
void init_sal(struct symtab_and_line *sal)
Definition: symtab.c:1064
struct tui_list * tui_source_windows(void)
Definition: tui-data.c:159
void tui_update_exec_info(struct tui_win_info *win_info)
void tui_set_win_focus_to(struct tui_win_info *win_info)
Definition: tui-win.c:554
union tui_line_or_address::@171 u
void tui_set_is_exec_point_at(struct tui_line_or_address l, struct tui_win_info *win_info)
#define TUI_BP_ENABLED
Definition: tui-data.h:205
WINDOW * handle
Definition: tui-data.h:42
enum tui_line_or_address_kind loa
Definition: tui-data.h:142
void tui_update_locator_fullname(const char *fullname)
Definition: tui-stack.c:347
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
int hit_count
Definition: breakpoint.h:750
#define TUI_BP_BREAK_POS
Definition: tui-data.h:213
struct bp_location * next
Definition: breakpoint.h:307
tui_scroll_direction
Definition: tui-data.h:96
struct gdbarch * gdbarch
Definition: tui-data.h:262
void tui_erase_source_content(struct tui_win_info *win_info, int display_prompt)
struct tui_gen_win_info generic
Definition: tui-data.h:277
struct tui_source_info source_info
Definition: tui-data.h:280
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
void tui_show_source_content(struct tui_win_info *win_info)
#define SYMTAB_OBJFILE(symtab)
Definition: symtab.h:970
void tui_clear_exec_info_content(struct tui_win_info *win_info)
void tui_show_disassem(struct gdbarch *gdbarch, CORE_ADDR start_addr)
Definition: tui-disasm.c:275
Definition: tui.h:39
tui_win_content tui_alloc_content(int num_elements, enum tui_win_type type)
Definition: tui-data.c:577
#define NO_DISASSEM_STRING
Definition: tui-data.h:59
void tui_clear_source_content(struct tui_win_info *win_info, int display_prompt)
struct tui_win_info * tui_win_with_focus(void)
Definition: tui-data.c:125
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
static struct tui_gen_win_info exec_info[2]
Definition: tui-data.c:40
int tui_addr_is_displayed(CORE_ADDR addr, struct tui_win_info *win_info, int check_threshold)
tui_status
Definition: tui.h:30
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define SYMTAB_PSPACE(symtab)
Definition: symtab.h:972
Definition: symtab.h:925
struct breakpoint * breakpoint_chain
Definition: breakpoint.c:595
void * xmalloc(YYSIZE_T)
struct symtab * symtab
Definition: symtab.h:1369
enum tui_status tui_set_exec_info_content(struct tui_win_info *win_info)
struct tui_win_info ** list
Definition: tui-data.h:108
static void tui_show_source_line(struct tui_win_info *win_info, int lineno)
#define TUI_BP_HARDWARE
Definition: tui-data.h:209
#define TUI_BP_CONDITIONAL
Definition: tui-data.h:208
int find_line_pc(struct symtab *symtab, int line, CORE_ADDR *pc)
Definition: symtab.c:3484
enum bptype type
Definition: breakpoint.h:669
union tui_which_element which_element
Definition: tui-data.h:233
int content_in_use
Definition: tui-data.h:49
const char const char int
Definition: command.h:229
#define TUI_SRC_WIN
Definition: tui-data.h:300
void tui_update_source_windows_with_line(struct symtab *s, int line)
#define NO_SRC_STRING
Definition: tui-data.h:58
#define SCROLL_THRESHOLD
Definition: tui-winsource.h:77
struct tui_win_element ** tui_win_content
Definition: tui-data.h:37
struct tui_gen_win_info * execution_info
Definition: tui-data.h:254
void tui_update_source_windows_with_addr(struct gdbarch *gdbarch, CORE_ADDR addr)
struct ui_file * gdb_stderr
Definition: main.c:72
struct bp_location * loc
Definition: breakpoint.h:678
struct program_space * pspace
Definition: symtab.h:1367
int offset
Definition: agent.c:65
void tui_show_symtab_source(struct gdbarch *gdbarch, struct symtab *s, struct tui_line_or_address line, int noerror)
Definition: tui-source.c:323
int count
Definition: tui-data.h:109
struct symtab_and_line set_current_source_symtab_and_line(const struct symtab_and_line *sal)
Definition: source.c:219
int line
Definition: symtab.h:1570
void tui_update_all_breakpoint_info(void)
void tui_erase_exec_info_content(struct tui_win_info *win_info)
#define TUI_DISASM_WIN
Definition: tui-data.h:301
void tui_check_and_display_highlight_if_needed(struct tui_win_info *win_info)
union tui_win_info::@172 detail
#define EMPTY_SOURCE_PROMPT
Definition: tui-data.h:75
void tui_show_exec_info_content(struct tui_win_info *win_info)
#define TUI_BP_HIT_POS
Definition: tui-data.h:212
void tui_refresh_win(struct tui_gen_win_info *win_info)
CORE_ADDR address
Definition: breakpoint.h:410
void tui_show_disassem_and_update_source(struct gdbarch *gdbarch, CORE_ADDR start_addr)
Definition: tui-disasm.c:298
#define TUI_BP_DISABLED
Definition: tui-data.h:206
enum tui_status tui_alloc_source_buffer(struct tui_win_info *win_info)
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
Definition: symtab.c:3328
enum enable_state enable_state
Definition: breakpoint.h:671
void tui_set_source_content_nil(struct tui_win_info *win_info, char *warning_string)
Definition: tui-source.c:253
#define TUI_EXEC_POS
Definition: tui-data.h:214
struct tui_source_element source
Definition: tui-data.h:222
enum tui_status tui_set_disassem_content(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: tui-disasm.c:171
CORE_ADDR addr
Definition: tui-data.h:146
char * fullname
Definition: tui-data.h:259
void tui_update_source_window_as_is(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:87
struct expression * cond
Definition: breakpoint.h:333
void tui_display_main(void)
Definition: tui-winsource.c:44
int tui_line_is_displayed(int line, struct tui_win_info *win_info, int check_threshold)
enum tui_layout_type tui_current_layout(void)
Definition: tui-data.c:294
struct breakpoint * next
Definition: breakpoint.h:667