1 /* TUI display source/assembly window.
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/>. */
26 #include "breakpoint.h"
30 #include "filenames.h"
33 #include "tui/tui-data.h"
34 #include "tui/tui-io.h"
35 #include "tui/tui-stack.h"
36 #include "tui/tui-win.h"
37 #include "tui/tui-wingeneral.h"
38 #include "tui/tui-winsource.h"
39 #include "tui/tui-source.h"
40 #include "tui/tui-disasm.h"
41 #include "gdb_curses.h"
43 /* Function to display the "main" routine. */
47 auto adapter = tui_source_windows ();
48 if (adapter.begin () != adapter.end ())
50 struct gdbarch *gdbarch;
53 tui_get_begin_asm_address (&gdbarch, &addr);
54 if (addr != (CORE_ADDR) 0)
58 tui_update_source_windows_with_addr (gdbarch, addr);
59 s = find_pc_line_symtab (addr);
61 tui_update_locator_fullname (symtab_to_fullname (s));
63 tui_update_locator_fullname ("??");
70 /* Function to display source in the source window. This function
71 initializes the horizontal scroll to 0. */
73 tui_source_window_base::update_source_window
74 (struct gdbarch *gdbarch,
76 struct tui_line_or_address line_or_addr)
78 horizontal_offset = 0;
79 update_source_window_as_is (gdbarch, s, line_or_addr);
83 /* Function to display source in the source/asm window. This function
84 shows the source as specified by the horizontal offset. */
86 tui_source_window_base::update_source_window_as_is
87 (struct gdbarch *gdbarch,
89 struct tui_line_or_address line_or_addr)
94 ret = tui_set_source_content (this, s, line_or_addr.u.line_no);
96 ret = tui_set_disassem_content (this, gdbarch, line_or_addr.u.addr);
98 if (ret == TUI_FAILURE)
99 erase_source_content ();
102 tui_update_breakpoint_info (this, nullptr, false);
103 show_source_content ();
109 sal.line = line_or_addr.u.line_no + (content.size () - 2);
111 sal.pspace = SYMTAB_PSPACE (s);
112 set_current_source_symtab_and_line (sal);
113 /* If the focus was in the asm win, put it in the src win if
114 we don't have a split layout. */
115 if (tui_win_with_focus () == TUI_DISASM_WIN
116 && tui_current_layout () != SRC_DISASSEM_COMMAND)
117 tui_set_win_focus_to (this);
123 /* Function to ensure that the source and/or disassemly windows
124 reflect the input address. */
126 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
130 struct symtab_and_line sal;
131 struct tui_line_or_address l;
133 switch (tui_current_layout ())
135 case DISASSEM_COMMAND:
136 case DISASSEM_DATA_COMMAND:
137 tui_show_disassem (gdbarch, addr);
139 case SRC_DISASSEM_COMMAND:
140 tui_show_disassem_and_update_source (gdbarch, addr);
143 sal = find_pc_line (addr, 0);
145 l.u.line_no = sal.line;
146 tui_show_symtab_source (TUI_SRC_WIN, gdbarch, sal.symtab, l);
152 for (struct tui_source_window_base *win_info : tui_source_windows ())
153 win_info->erase_source_content ();
157 /* Function to ensure that the source and/or disassemly windows
158 reflect the input address. */
160 tui_update_source_windows_with_line (struct symtab *s, int line)
162 struct gdbarch *gdbarch;
164 struct tui_line_or_address l;
169 gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
171 switch (tui_current_layout ())
173 case DISASSEM_COMMAND:
174 case DISASSEM_DATA_COMMAND:
175 find_line_pc (s, line, &pc);
176 tui_update_source_windows_with_addr (gdbarch, pc);
181 tui_show_symtab_source (TUI_SRC_WIN, gdbarch, s, l);
182 if (tui_current_layout () == SRC_DISASSEM_COMMAND)
184 find_line_pc (s, line, &pc);
185 tui_show_disassem (gdbarch, pc);
192 tui_source_window_base::do_erase_source_content (const char *str)
195 int half_width = (width - 2) / 2;
201 check_and_display_highlight_if_needed ();
203 if (strlen (str) >= half_width)
206 x_pos = half_width - strlen (str);
214 werase (execution_info->handle);
215 execution_info->refresh_window ();
220 /* Redraw the complete line of a source or disassembly window. */
222 tui_show_source_line (struct tui_source_window_base *win_info, int lineno)
224 struct tui_source_element *line;
227 line = &win_info->content[lineno - 1];
228 if (line->is_exec_point)
229 tui_set_reverse_mode (win_info->handle, true);
231 wmove (win_info->handle, lineno, 1);
232 tui_puts (line->line,
234 if (line->is_exec_point)
235 tui_set_reverse_mode (win_info->handle, false);
237 /* Clear to end of line but stop before the border. */
238 x = getcurx (win_info->handle);
239 while (x + 1 < win_info->width)
241 waddch (win_info->handle, ' ');
242 x = getcurx (win_info->handle);
247 tui_source_window_base::show_source_content ()
249 if (!content.empty ())
253 for (lineno = 1; lineno <= content.size (); lineno++)
254 tui_show_source_line (this, lineno);
257 erase_source_content ();
259 check_and_display_highlight_if_needed ();
263 /* See tui-data.h. */
266 tui_source_window_base::clear_detail ()
269 start_line_or_addr.loa = LOA_ADDRESS;
270 start_line_or_addr.u.addr = 0;
271 horizontal_offset = 0;
274 tui_source_window_base::tui_source_window_base (enum tui_win_type type)
275 : tui_win_info (type),
276 execution_info (new tui_exec_info_window ())
278 gdb_assert (type == SRC_WIN || type == DISASSEM_WIN);
279 start_line_or_addr.loa = LOA_ADDRESS;
280 start_line_or_addr.u.addr = 0;
284 tui_source_window_base::~tui_source_window_base ()
287 delete execution_info;
291 tui_source_window_base::resize (int height, int width,
292 int origin_x, int origin_y)
294 tui_gen_win_info::resize (height, width - 3,
295 origin_x + 3, origin_y);
296 execution_info->resize (height, 3, origin_x, origin_y);
299 /* See tui-data.h. */
302 tui_source_window_base::refresh_all ()
304 show_source_content ();
305 check_and_display_highlight_if_needed ();
309 /* See tui-data.h. */
312 tui_source_window_base::update_tab_width ()
319 tui_source_window_base::rerender ()
321 if (!content.empty ())
323 struct tui_line_or_address line_or_addr;
324 struct symtab_and_line cursal
325 = get_current_source_symtab_and_line ();
327 line_or_addr = start_line_or_addr;
328 update_source_window (gdbarch, cursal.symtab, line_or_addr);
330 else if (deprecated_safe_get_selected_frame () != NULL)
332 struct tui_line_or_address line;
333 struct symtab_and_line cursal
334 = get_current_source_symtab_and_line ();
335 struct frame_info *frame = deprecated_safe_get_selected_frame ();
336 struct gdbarch *gdbarch = get_frame_arch (frame);
338 struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
342 line.u.line_no = cursal.line;
346 line.loa = LOA_ADDRESS;
347 find_line_pc (s, cursal.line, &line.u.addr);
349 update_source_window (gdbarch, s, line);
352 erase_source_content ();
355 /* See tui-data.h. */
358 tui_source_window_base::make_visible (bool visible)
360 execution_info->make_visible (visible);
361 tui_win_info::make_visible (visible);
364 /* See tui-data.h. */
367 tui_source_window_base::refresh_window ()
369 execution_info->refresh_window ();
370 tui_win_info::refresh_window ();
373 /* See tui-data.h. */
376 tui_source_window_base::refill ()
382 symtab_and_line cursal = get_current_source_symtab_and_line ();
383 s = (cursal.symtab == NULL
384 ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
388 update_source_window_as_is (gdbarch, s, content[0].line_or_addr);
391 /* Scroll the source forward or backward horizontally. */
394 tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
396 if (!content.empty ())
398 int offset = horizontal_offset + num_to_scroll;
401 horizontal_offset = offset;
407 /* Set or clear the is_exec_point flag in the line whose line is
411 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
413 bool changed = false;
417 while (i < content.size ())
420 struct tui_line_or_address content_loa =
421 content[i].line_or_addr;
423 gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
424 gdb_assert (content_loa.loa == LOA_LINE
425 || content_loa.loa == LOA_ADDRESS);
426 if (content_loa.loa == l.loa
427 && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
428 || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
432 if (new_state != content[i].is_exec_point)
435 content[i].is_exec_point = new_state;
436 tui_show_source_line (this, i + 1);
444 /* See tui-winsource.h. */
447 tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
449 for (tui_source_window_base *win : tui_source_windows ())
451 if (tui_update_breakpoint_info (win, being_deleted, false))
453 win->update_exec_info ();
459 /* Scan the source window and the breakpoints to update the break_mode
460 information for each line.
462 Returns true if something changed and the execution window must be
466 tui_update_breakpoint_info (struct tui_source_window_base *win,
467 struct breakpoint *being_deleted,
471 bool need_refresh = false;
473 for (i = 0; i < win->content.size (); i++)
475 struct breakpoint *bp;
476 extern struct breakpoint *breakpoint_chain;
477 struct tui_source_element *line;
479 line = &win->content[i];
480 if (current_only && !line->is_exec_point)
483 /* Scan each breakpoint to see if the current line has something to
484 do with it. Identify enable/disabled breakpoints as well as
485 those that we already hit. */
486 tui_bp_flags mode = 0;
487 for (bp = breakpoint_chain;
491 struct bp_location *loc;
493 gdb_assert (line->line_or_addr.loa == LOA_LINE
494 || line->line_or_addr.loa == LOA_ADDRESS);
496 if (bp == being_deleted)
499 for (loc = bp->loc; loc != NULL; loc = loc->next)
501 if (win->location_matches_p (loc, i))
503 if (bp->enable_state == bp_disabled)
504 mode |= TUI_BP_DISABLED;
506 mode |= TUI_BP_ENABLED;
510 mode |= TUI_BP_CONDITIONAL;
511 if (bp->type == bp_hardware_breakpoint)
512 mode |= TUI_BP_HARDWARE;
516 if (line->break_mode != mode)
518 line->break_mode = mode;
525 /* Function to initialize the content of the execution info window,
526 based upon the input window which is either the source or
527 disassembly window. */
529 tui_source_window_base::update_exec_info ()
531 werase (execution_info->handle);
532 tui_update_breakpoint_info (this, nullptr, true);
533 for (int i = 0; i < content.size (); i++)
535 struct tui_source_element *src_element = &content[i];
536 char element[TUI_EXECINFO_SIZE] = " ";
538 /* Now update the exec info content based upon the state
539 of each line as indicated by the source content. */
540 tui_bp_flags mode = src_element->break_mode;
541 if (mode & TUI_BP_HIT)
542 element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
543 else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
544 element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
546 if (mode & TUI_BP_ENABLED)
547 element[TUI_BP_BREAK_POS] = '+';
548 else if (mode & TUI_BP_DISABLED)
549 element[TUI_BP_BREAK_POS] = '-';
551 if (src_element->is_exec_point)
552 element[TUI_EXEC_POS] = '>';
554 mvwaddstr (execution_info->handle, i + 1, 0, element);
556 execution_info->refresh_window ();