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