1 /* TUI display source/assembly window. 2 3 Copyright (C) 1998-2020 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-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" 42 43 /* Function to display the "main" routine. */ 44 void 45 tui_display_main () 46 { 47 auto adapter = tui_source_windows (); 48 if (adapter.begin () != adapter.end ()) 49 { 50 struct gdbarch *gdbarch; 51 CORE_ADDR addr; 52 53 tui_get_begin_asm_address (&gdbarch, &addr); 54 if (addr != (CORE_ADDR) 0) 55 { 56 struct symtab *s; 57 58 tui_update_source_windows_with_addr (gdbarch, addr); 59 s = find_pc_line_symtab (addr); 60 tui_update_locator_fullname (s); 61 } 62 } 63 } 64 65 /* See tui-winsource.h. */ 66 67 std::string 68 tui_copy_source_line (const char **ptr, int line_no, int first_col, 69 int line_width, int ndigits) 70 { 71 const char *lineptr = *ptr; 72 73 /* Init the line with the line number. */ 74 std::string result; 75 76 if (line_no > 0) 77 { 78 if (ndigits > 0) 79 result = string_printf ("%*d ", ndigits, line_no); 80 else 81 { 82 result = string_printf ("%-6d", line_no); 83 int len = result.size (); 84 len = len - ((len / tui_tab_width) * tui_tab_width); 85 result.append (len, ' '); 86 } 87 } 88 89 int column = 0; 90 char c; 91 do 92 { 93 int skip_bytes; 94 95 c = *lineptr; 96 if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes)) 97 { 98 /* We always have to preserve escapes. */ 99 result.append (lineptr, lineptr + skip_bytes); 100 lineptr += skip_bytes; 101 continue; 102 } 103 if (c == '\0') 104 break; 105 106 ++lineptr; 107 ++column; 108 109 auto process_tab = [&] () 110 { 111 int max_tab_len = tui_tab_width; 112 113 --column; 114 for (int j = column % max_tab_len; 115 j < max_tab_len && column < first_col + line_width; 116 column++, j++) 117 if (column >= first_col) 118 result.push_back (' '); 119 }; 120 121 /* We have to process all the text in order to pick up all the 122 escapes. */ 123 if (column <= first_col || column > first_col + line_width) 124 { 125 if (c == '\t') 126 process_tab (); 127 continue; 128 } 129 130 if (c == '\n' || c == '\r' || c == '\0') 131 { 132 /* Nothing. */ 133 } 134 else if (c < 040 && c != '\t') 135 { 136 result.push_back ('^'); 137 result.push_back (c + 0100); 138 } 139 else if (c == 0177) 140 { 141 result.push_back ('^'); 142 result.push_back ('?'); 143 } 144 else if (c == '\t') 145 process_tab (); 146 else 147 result.push_back (c); 148 } 149 while (c != '\0' && c != '\n' && c != '\r'); 150 151 if (c == '\r' && *lineptr == '\n') 152 ++lineptr; 153 *ptr = lineptr; 154 155 return result; 156 } 157 158 void 159 tui_source_window_base::style_changed () 160 { 161 if (tui_active && is_visible ()) 162 refill (); 163 } 164 165 /* Function to display source in the source window. This function 166 initializes the horizontal scroll to 0. */ 167 void 168 tui_source_window_base::update_source_window 169 (struct gdbarch *gdbarch, 170 const struct symtab_and_line &sal) 171 { 172 m_horizontal_offset = 0; 173 update_source_window_as_is (gdbarch, sal); 174 } 175 176 177 /* Function to display source in the source/asm window. This function 178 shows the source as specified by the horizontal offset. */ 179 void 180 tui_source_window_base::update_source_window_as_is 181 (struct gdbarch *gdbarch, 182 const struct symtab_and_line &sal) 183 { 184 bool ret = set_contents (gdbarch, sal); 185 186 if (!ret) 187 erase_source_content (); 188 else 189 { 190 update_breakpoint_info (nullptr, false); 191 show_source_content (); 192 update_exec_info (); 193 } 194 } 195 196 197 /* Function to ensure that the source and/or disassemly windows 198 reflect the input address. */ 199 void 200 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr) 201 { 202 struct symtab_and_line sal {}; 203 if (addr != 0) 204 sal = find_pc_line (addr, 0); 205 206 for (struct tui_source_window_base *win_info : tui_source_windows ()) 207 win_info->update_source_window (gdbarch, sal); 208 } 209 210 /* Function to ensure that the source and/or disassembly windows 211 reflect the symtab and line. */ 212 void 213 tui_update_source_windows_with_line (struct symtab_and_line sal) 214 { 215 struct gdbarch *gdbarch = nullptr; 216 if (sal.symtab != nullptr) 217 { 218 find_line_pc (sal.symtab, sal.line, &sal.pc); 219 gdbarch = SYMTAB_OBJFILE (sal.symtab)->arch (); 220 } 221 222 for (struct tui_source_window_base *win_info : tui_source_windows ()) 223 win_info->update_source_window (gdbarch, sal); 224 } 225 226 void 227 tui_source_window_base::do_erase_source_content (const char *str) 228 { 229 int x_pos; 230 int half_width = (width - 2) / 2; 231 232 m_content.clear (); 233 if (handle != NULL) 234 { 235 werase (handle.get ()); 236 check_and_display_highlight_if_needed (); 237 238 if (strlen (str) >= half_width) 239 x_pos = 1; 240 else 241 x_pos = half_width - strlen (str); 242 mvwaddstr (handle.get (), 243 (height / 2), 244 x_pos, 245 (char *) str); 246 247 refresh_window (); 248 } 249 } 250 251 252 /* Redraw the complete line of a source or disassembly window. */ 253 void 254 tui_source_window_base::show_source_line (int lineno) 255 { 256 struct tui_source_element *line; 257 int x; 258 259 line = &m_content[lineno - 1]; 260 if (line->is_exec_point) 261 tui_set_reverse_mode (handle.get (), true); 262 263 wmove (handle.get (), lineno, TUI_EXECINFO_SIZE); 264 tui_puts (line->line.c_str (), handle.get ()); 265 if (line->is_exec_point) 266 tui_set_reverse_mode (handle.get (), false); 267 268 /* Clear to end of line but stop before the border. */ 269 x = getcurx (handle.get ()); 270 while (x + 1 < width) 271 { 272 waddch (handle.get (), ' '); 273 x = getcurx (handle.get ()); 274 } 275 } 276 277 void 278 tui_source_window_base::show_source_content () 279 { 280 gdb_assert (!m_content.empty ()); 281 282 for (int lineno = 1; lineno <= m_content.size (); lineno++) 283 show_source_line (lineno); 284 285 check_and_display_highlight_if_needed (); 286 refresh_window (); 287 } 288 289 tui_source_window_base::tui_source_window_base () 290 { 291 m_start_line_or_addr.loa = LOA_ADDRESS; 292 m_start_line_or_addr.u.addr = 0; 293 294 gdb::observers::source_styling_changed.attach 295 (std::bind (&tui_source_window::style_changed, this), 296 m_observable); 297 } 298 299 tui_source_window_base::~tui_source_window_base () 300 { 301 gdb::observers::source_styling_changed.detach (m_observable); 302 } 303 304 /* See tui-data.h. */ 305 306 void 307 tui_source_window_base::update_tab_width () 308 { 309 werase (handle.get ()); 310 rerender (); 311 } 312 313 void 314 tui_source_window_base::rerender () 315 { 316 if (!m_content.empty ()) 317 { 318 struct symtab_and_line cursal 319 = get_current_source_symtab_and_line (); 320 321 if (m_start_line_or_addr.loa == LOA_LINE) 322 cursal.line = m_start_line_or_addr.u.line_no; 323 else 324 cursal.pc = m_start_line_or_addr.u.addr; 325 update_source_window (m_gdbarch, cursal); 326 } 327 else if (deprecated_safe_get_selected_frame () != NULL) 328 { 329 struct symtab_and_line cursal 330 = get_current_source_symtab_and_line (); 331 struct frame_info *frame = deprecated_safe_get_selected_frame (); 332 struct gdbarch *gdbarch = get_frame_arch (frame); 333 334 struct symtab *s = find_pc_line_symtab (get_frame_pc (frame)); 335 if (this != TUI_SRC_WIN) 336 find_line_pc (s, cursal.line, &cursal.pc); 337 update_source_window (gdbarch, cursal); 338 } 339 else 340 erase_source_content (); 341 } 342 343 /* See tui-data.h. */ 344 345 void 346 tui_source_window_base::refill () 347 { 348 symtab_and_line sal {}; 349 350 if (this == TUI_SRC_WIN) 351 { 352 sal = get_current_source_symtab_and_line (); 353 if (sal.symtab == NULL) 354 { 355 struct frame_info *fi = deprecated_safe_get_selected_frame (); 356 if (fi != nullptr) 357 sal = find_pc_line (get_frame_pc (fi), 0); 358 } 359 } 360 361 if (sal.pspace == nullptr) 362 sal.pspace = current_program_space; 363 364 if (m_start_line_or_addr.loa == LOA_LINE) 365 sal.line = m_start_line_or_addr.u.line_no; 366 else 367 sal.pc = m_start_line_or_addr.u.addr; 368 369 update_source_window_as_is (m_gdbarch, sal); 370 } 371 372 /* Scroll the source forward or backward horizontally. */ 373 374 void 375 tui_source_window_base::do_scroll_horizontal (int num_to_scroll) 376 { 377 if (!m_content.empty ()) 378 { 379 int offset = m_horizontal_offset + num_to_scroll; 380 if (offset < 0) 381 offset = 0; 382 m_horizontal_offset = offset; 383 refill (); 384 } 385 } 386 387 388 /* Set or clear the is_exec_point flag in the line whose line is 389 line_no. */ 390 391 void 392 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l) 393 { 394 bool changed = false; 395 int i; 396 397 i = 0; 398 while (i < m_content.size ()) 399 { 400 bool new_state; 401 struct tui_line_or_address content_loa = 402 m_content[i].line_or_addr; 403 404 if (content_loa.loa == l.loa 405 && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no) 406 || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr))) 407 new_state = true; 408 else 409 new_state = false; 410 if (new_state != m_content[i].is_exec_point) 411 { 412 changed = true; 413 m_content[i].is_exec_point = new_state; 414 show_source_line (i + 1); 415 } 416 i++; 417 } 418 if (changed) 419 refill (); 420 } 421 422 /* See tui-winsource.h. */ 423 424 void 425 tui_update_all_breakpoint_info (struct breakpoint *being_deleted) 426 { 427 for (tui_source_window_base *win : tui_source_windows ()) 428 { 429 if (win->update_breakpoint_info (being_deleted, false)) 430 win->update_exec_info (); 431 } 432 } 433 434 435 /* Scan the source window and the breakpoints to update the break_mode 436 information for each line. 437 438 Returns true if something changed and the execution window must be 439 refreshed. */ 440 441 bool 442 tui_source_window_base::update_breakpoint_info 443 (struct breakpoint *being_deleted, bool current_only) 444 { 445 int i; 446 bool need_refresh = false; 447 448 for (i = 0; i < m_content.size (); i++) 449 { 450 struct tui_source_element *line; 451 452 line = &m_content[i]; 453 if (current_only && !line->is_exec_point) 454 continue; 455 456 /* Scan each breakpoint to see if the current line has something to 457 do with it. Identify enable/disabled breakpoints as well as 458 those that we already hit. */ 459 tui_bp_flags mode = 0; 460 iterate_over_breakpoints ([&] (breakpoint *bp) -> bool 461 { 462 struct bp_location *loc; 463 464 if (bp == being_deleted) 465 return false; 466 467 for (loc = bp->loc; loc != NULL; loc = loc->next) 468 { 469 if (location_matches_p (loc, i)) 470 { 471 if (bp->enable_state == bp_disabled) 472 mode |= TUI_BP_DISABLED; 473 else 474 mode |= TUI_BP_ENABLED; 475 if (bp->hit_count) 476 mode |= TUI_BP_HIT; 477 if (bp->loc->cond) 478 mode |= TUI_BP_CONDITIONAL; 479 if (bp->type == bp_hardware_breakpoint) 480 mode |= TUI_BP_HARDWARE; 481 } 482 } 483 return false; 484 }); 485 if (line->break_mode != mode) 486 { 487 line->break_mode = mode; 488 need_refresh = true; 489 } 490 } 491 return need_refresh; 492 } 493 494 /* Function to initialize the content of the execution info window, 495 based upon the input window which is either the source or 496 disassembly window. */ 497 void 498 tui_source_window_base::update_exec_info () 499 { 500 update_breakpoint_info (nullptr, true); 501 for (int i = 0; i < m_content.size (); i++) 502 { 503 struct tui_source_element *src_element = &m_content[i]; 504 char element[TUI_EXECINFO_SIZE] = " "; 505 506 /* Now update the exec info content based upon the state 507 of each line as indicated by the source content. */ 508 tui_bp_flags mode = src_element->break_mode; 509 if (mode & TUI_BP_HIT) 510 element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B'; 511 else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED)) 512 element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b'; 513 514 if (mode & TUI_BP_ENABLED) 515 element[TUI_BP_BREAK_POS] = '+'; 516 else if (mode & TUI_BP_DISABLED) 517 element[TUI_BP_BREAK_POS] = '-'; 518 519 if (src_element->is_exec_point) 520 element[TUI_EXEC_POS] = '>'; 521 522 mvwaddstr (handle.get (), i + 1, 1, element); 523 } 524 refresh_window (); 525 } 526