gdb/tui/tui-winsource.c

   1 /* TUI display source/assembly window.
   2
   3    Copyright (C) 1998-2019 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 (void)
  46 {
  47   if ((tui_source_windows ())->count > 0)
  48     {
  49       struct gdbarch *gdbarch;
  50       CORE_ADDR addr;
  51
  52       tui_get_begin_asm_address (&gdbarch, &addr);
  53       if (addr != (CORE_ADDR) 0)
  54         {
  55           struct symtab *s;
  56
  57           tui_update_source_windows_with_addr (gdbarch, addr);
  58           s = find_pc_line_symtab (addr);
  59           if (s != NULL)
  60              tui_update_locator_fullname (symtab_to_fullname (s));
  61           else
  62              tui_update_locator_fullname ("??");
  63         }
  64     }
  65 }
  66
  67
  68
  69 /* Function to display source in the source window.  This function
  70    initializes the horizontal scroll to 0.  */
  71 void
  72 tui_update_source_window (struct tui_win_info *win_info,
  73                           struct gdbarch *gdbarch,
  74                           struct symtab *s,
  75                           struct tui_line_or_address line_or_addr,
  76                           int noerror)
  77 {
  78   win_info->detail.source_info.horizontal_offset = 0;
  79   tui_update_source_window_as_is (win_info, gdbarch, s, line_or_addr, noerror);
  80
  81   return;
  82 }
  83
  84
  85 /* Function to display source in the source/asm window.  This function
  86    shows the source as specified by the horizontal offset.  */
  87 void
  88 tui_update_source_window_as_is (struct tui_win_info *win_info,
  89                                 struct gdbarch *gdbarch,
  90                                 struct symtab *s,
  91                                 struct tui_line_or_address line_or_addr,
  92                                 int noerror)
  93 {
  94   enum tui_status ret;
  95
  96   if (win_info->generic.type == SRC_WIN)
  97     ret = tui_set_source_content (s, line_or_addr.u.line_no, noerror);
  98   else
  99     ret = tui_set_disassem_content (gdbarch, line_or_addr.u.addr);
 100
 101   if (ret == TUI_FAILURE)
 102     {
 103       tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 104       tui_clear_exec_info_content (win_info);
 105     }
 106   else
 107     {
 108       tui_update_breakpoint_info (win_info, 0);
 109       tui_show_source_content (win_info);
 110       tui_update_exec_info (win_info);
 111       if (win_info->generic.type == SRC_WIN)
 112         {
 113           symtab_and_line sal;
 114
 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);
 119           set_current_source_symtab_and_line (sal);
 120           /* If the focus was in the asm win, put it in the src win if
 121              we don't have a split layout.  */
 122           if (tui_win_with_focus () == TUI_DISASM_WIN
 123               && tui_current_layout () != SRC_DISASSEM_COMMAND)
 124             tui_set_win_focus_to (TUI_SRC_WIN);
 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
 136 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 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:
 146         case DISASSEM_DATA_COMMAND:
 147           tui_show_disassem (gdbarch, addr);
 148           break;
 149         case SRC_DISASSEM_COMMAND:
 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
 168           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 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
 177 tui_update_source_windows_with_line (struct symtab *s, int line)
 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:
 191     case DISASSEM_DATA_COMMAND:
 192       find_line_pc (s, line, &pc);
 193       tui_update_source_windows_with_addr (gdbarch, 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);
 199       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 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
 211 tui_clear_source_content (struct tui_win_info *win_info,
 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
 232 tui_erase_source_content (struct tui_win_info *win_info,
 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);
 241       tui_check_and_display_highlight_if_needed (win_info);
 242       if (display_prompt == EMPTY_SOURCE_PROMPT)
 243         {
 244           const 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                      (char *) 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
 277   line = win_info->generic.content[lineno - 1];
 278   if (line->which_element.source.is_exec_point)
 279     wattron (win_info->generic.handle, A_STANDOUT);
 280
 281   wmove (win_info->generic.handle, lineno, 1);
 282   tui_puts (line->which_element.source.line,
 283             win_info->generic.handle);
 284   if (line->which_element.source.is_exec_point)
 285     wattroff (win_info->generic.handle, A_STANDOUT);
 286
 287   /* Clear to end of line but stop before the border.  */
 288   wclrtoeol (win_info->generic.handle);
 289 }
 290
 291 void
 292 tui_show_source_content (struct tui_win_info *win_info)
 293 {
 294   if (win_info->generic.content_size > 0)
 295     {
 296       int lineno;
 297
 298       for (lineno = 1; lineno <= win_info->generic.content_size; lineno++)
 299         tui_show_source_line (win_info, lineno);
 300     }
 301   else
 302     tui_erase_source_content (win_info, TRUE);
 303
 304   tui_check_and_display_highlight_if_needed (win_info);
 305   tui_refresh_win (&win_info->generic);
 306   win_info->generic.content_in_use = TRUE;
 307 }
 308
 309
 310 /* Scroll the source forward or backward horizontally.  */
 311 void
 312 tui_horizontal_source_scroll (struct tui_win_info *win_info,
 313                               enum tui_scroll_direction direction,
 314                               int num_to_scroll)
 315 {
 316   if (win_info->generic.content != NULL)
 317     {
 318       struct gdbarch *gdbarch = win_info->detail.source_info.gdbarch;
 319       int offset;
 320       struct symtab *s = NULL;
 321
 322       if (win_info->generic.type == SRC_WIN)
 323         {
 324           struct symtab_and_line cursal
 325             = get_current_source_symtab_and_line ();
 326
 327           if (cursal.symtab == NULL)
 328             s = find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)));
 329           else
 330             s = cursal.symtab;
 331         }
 332
 333       if (direction == LEFT_SCROLL)
 334         offset = win_info->detail.source_info.horizontal_offset
 335           + num_to_scroll;
 336       else
 337         {
 338           offset = win_info->detail.source_info.horizontal_offset
 339             - num_to_scroll;
 340           if (offset < 0)
 341             offset = 0;
 342         }
 343       win_info->detail.source_info.horizontal_offset = offset;
 344       tui_update_source_window_as_is (win_info, gdbarch, s,
 345                                       win_info->generic.content[0]
 346                                         ->which_element.source.line_or_addr,
 347                                       FALSE);
 348     }
 349
 350   return;
 351 }
 352
 353
 354 /* Set or clear the has_break flag in the line whose line is
 355    line_no.  */
 356
 357 void
 358 tui_set_is_exec_point_at (struct tui_line_or_address l,
 359                           struct tui_win_info *win_info)
 360 {
 361   int changed = 0;
 362   int i;
 363   tui_win_content content = win_info->generic.content;
 364
 365   i = 0;
 366   while (i < win_info->generic.content_size)
 367     {
 368       int new_state;
 369       struct tui_line_or_address content_loa =
 370         content[i]->which_element.source.line_or_addr;
 371
 372       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 373       gdb_assert (content_loa.loa == LOA_LINE
 374                   || content_loa.loa == LOA_ADDRESS);
 375       if (content_loa.loa == l.loa
 376           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 377               || (content_loa.u.addr == l.u.addr)))
 378         new_state = TRUE;
 379       else
 380         new_state = FALSE;
 381       if (new_state != content[i]->which_element.source.is_exec_point)
 382         {
 383           changed++;
 384           content[i]->which_element.source.is_exec_point = new_state;
 385           tui_show_source_line (win_info, i + 1);
 386         }
 387       i++;
 388     }
 389   if (changed)
 390     tui_refresh_win (&win_info->generic);
 391 }
 392
 393 /* Update the execution windows to show the active breakpoints.
 394    This is called whenever a breakpoint is inserted, removed or
 395    has its state changed.  */
 396 void
 397 tui_update_all_breakpoint_info (void)
 398 {
 399   struct tui_list *list = tui_source_windows ();
 400   int i;
 401
 402   for (i = 0; i < list->count; i++)
 403     {
 404       struct tui_win_info *win = list->list[i];
 405
 406       if (tui_update_breakpoint_info (win, FALSE))
 407         {
 408           tui_update_exec_info (win);
 409         }
 410     }
 411 }
 412
 413
 414 /* Scan the source window and the breakpoints to update the has_break
 415    information for each line.
 416
 417    Returns 1 if something changed and the execution window must be
 418    refreshed.  */
 419
 420 int
 421 tui_update_breakpoint_info (struct tui_win_info *win,
 422                             int current_only)
 423 {
 424   int i;
 425   int need_refresh = 0;
 426   struct tui_source_info *src = &win->detail.source_info;
 427
 428   for (i = 0; i < win->generic.content_size; i++)
 429     {
 430       struct breakpoint *bp;
 431       extern struct breakpoint *breakpoint_chain;
 432       int mode;
 433       struct tui_source_element *line;
 434
 435       line = &win->generic.content[i]->which_element.source;
 436       if (current_only && !line->is_exec_point)
 437          continue;
 438
 439       /* Scan each breakpoint to see if the current line has something to
 440          do with it.  Identify enable/disabled breakpoints as well as
 441          those that we already hit.  */
 442       mode = 0;
 443       for (bp = breakpoint_chain;
 444            bp != (struct breakpoint *) NULL;
 445            bp = bp->next)
 446         {
 447           struct bp_location *loc;
 448
 449           gdb_assert (line->line_or_addr.loa == LOA_LINE
 450                       || line->line_or_addr.loa == LOA_ADDRESS);
 451
 452           for (loc = bp->loc; loc != NULL; loc = loc->next)
 453             {
 454               if ((win == TUI_SRC_WIN
 455                    && loc->symtab != NULL
 456                    && filename_cmp (src->fullname,
 457                                     symtab_to_fullname (loc->symtab)) == 0
 458                    && line->line_or_addr.loa == LOA_LINE
 459                    && loc->line_number == line->line_or_addr.u.line_no)
 460                   || (win == TUI_DISASM_WIN
 461                       && line->line_or_addr.loa == LOA_ADDRESS
 462                       && loc->address == line->line_or_addr.u.addr))
 463                 {
 464                   if (bp->enable_state == bp_disabled)
 465                     mode |= TUI_BP_DISABLED;
 466                   else
 467                     mode |= TUI_BP_ENABLED;
 468                   if (bp->hit_count)
 469                     mode |= TUI_BP_HIT;
 470                   if (bp->loc->cond)
 471                     mode |= TUI_BP_CONDITIONAL;
 472                   if (bp->type == bp_hardware_breakpoint)
 473                     mode |= TUI_BP_HARDWARE;
 474                 }
 475             }
 476         }
 477       if (line->has_break != mode)
 478         {
 479           line->has_break = mode;
 480           need_refresh = 1;
 481         }
 482     }
 483   return need_refresh;
 484 }
 485
 486
 487 /* Function to initialize the content of the execution info window,
 488    based upon the input window which is either the source or
 489    disassembly window.  */
 490 enum tui_status
 491 tui_set_exec_info_content (struct tui_win_info *win_info)
 492 {
 493   enum tui_status ret = TUI_SUCCESS;
 494
 495   if (win_info->detail.source_info.execution_info
 496       != (struct tui_gen_win_info *) NULL)
 497     {
 498       struct tui_gen_win_info *exec_info_ptr
 499         = win_info->detail.source_info.execution_info;
 500
 501       if (exec_info_ptr->content == NULL)
 502         exec_info_ptr->content =
 503           tui_alloc_content (win_info->generic.height, exec_info_ptr->type);
 504       if (exec_info_ptr->content != NULL)
 505         {
 506           int i;
 507
 508           tui_update_breakpoint_info (win_info, 1);
 509           for (i = 0; i < win_info->generic.content_size; i++)
 510             {
 511               struct tui_win_element *element;
 512               struct tui_win_element *src_element;
 513               int mode;
 514
 515               element = exec_info_ptr->content[i];
 516               src_element = win_info->generic.content[i];
 517
 518               memset(element->which_element.simple_string, ' ',
 519                      sizeof(element->which_element.simple_string));
 520               element->which_element.simple_string[TUI_EXECINFO_SIZE - 1] = 0;
 521
 522               /* Now update the exec info content based upon the state
 523                  of each line as indicated by the source content.  */
 524               mode = src_element->which_element.source.has_break;
 525               if (mode & TUI_BP_HIT)
 526                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 527                   (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 528               else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 529                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 530                   (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 531
 532               if (mode & TUI_BP_ENABLED)
 533                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
 534               else if (mode & TUI_BP_DISABLED)
 535                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
 536
 537               if (src_element->which_element.source.is_exec_point)
 538                 element->which_element.simple_string[TUI_EXEC_POS] = '>';
 539             }
 540           exec_info_ptr->content_size = win_info->generic.content_size;
 541         }
 542       else
 543         ret = TUI_FAILURE;
 544     }
 545
 546   return ret;
 547 }
 548
 549
 550 void
 551 tui_show_exec_info_content (struct tui_win_info *win_info)
 552 {
 553   struct tui_gen_win_info *exec_info
 554     = win_info->detail.source_info.execution_info;
 555   int cur_line;
 556
 557   werase (exec_info->handle);
 558   tui_refresh_win (exec_info);
 559   for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
 560     mvwaddstr (exec_info->handle,
 561                cur_line,
 562                0,
 563                (char *) exec_info->content[cur_line - 1]
 564                           ->which_element.simple_string);
 565   tui_refresh_win (exec_info);
 566   exec_info->content_in_use = TRUE;
 567 }
 568
 569
 570 void
 571 tui_erase_exec_info_content (struct tui_win_info *win_info)
 572 {
 573   struct tui_gen_win_info *exec_info
 574     = win_info->detail.source_info.execution_info;
 575
 576   werase (exec_info->handle);
 577   tui_refresh_win (exec_info);
 578 }
 579
 580 void
 581 tui_clear_exec_info_content (struct tui_win_info *win_info)
 582 {
 583   win_info->detail.source_info.execution_info->content_in_use = FALSE;
 584   tui_erase_exec_info_content (win_info);
 585
 586   return;
 587 }
 588
 589 /* Function to update the execution info window.  */
 590 void
 591 tui_update_exec_info (struct tui_win_info *win_info)
 592 {
 593   tui_set_exec_info_content (win_info);
 594   tui_show_exec_info_content (win_info);
 595 }
 596
 597 enum tui_status
 598 tui_alloc_source_buffer (struct tui_win_info *win_info)
 599 {
 600   int i, line_width, max_lines;
 601
 602   /* The window width/height includes the highlight box.  Determine actual
 603      content dimensions, including string null-terminators.  */
 604   max_lines = win_info->generic.height - 2;
 605   line_width = win_info->generic.width - 2 + 1;
 606
 607   /* Allocate the buffer for the source lines.  */
 608   if (win_info->generic.content == NULL)
 609     {
 610       /* Allocate the content list.  */
 611       win_info->generic.content = tui_alloc_content (max_lines, SRC_WIN);
 612       for (i = 0; i < max_lines; i++)
 613         win_info->generic.content[i]->which_element.source.line
 614           = (char *) xmalloc (line_width);
 615     }
 616
 617   return TUI_SUCCESS;
 618 }
 619
 620
 621 /* Answer whether a particular line number or address is displayed
 622    in the current source window.  */
 623 int
 624 tui_line_is_displayed (int line,
 625                        struct tui_win_info *win_info,
 626                        int check_threshold)
 627 {
 628   int is_displayed = FALSE;
 629   int i, threshold;
 630
 631   if (check_threshold)
 632     threshold = SCROLL_THRESHOLD;
 633   else
 634     threshold = 0;
 635   i = 0;
 636   while (i < win_info->generic.content_size - threshold
 637          && !is_displayed)
 638     {
 639       is_displayed
 640         = win_info->generic.content[i]
 641             ->which_element.source.line_or_addr.loa == LOA_LINE
 642           && win_info->generic.content[i]
 643                ->which_element.source.line_or_addr.u.line_no == line;
 644       i++;
 645     }
 646
 647   return is_displayed;
 648 }
 649
 650
 651 /* Answer whether a particular line number or address is displayed
 652    in the current source window.  */
 653 int
 654 tui_addr_is_displayed (CORE_ADDR addr,
 655                        struct tui_win_info *win_info,
 656                        int check_threshold)
 657 {
 658   int is_displayed = FALSE;
 659   int i, threshold;
 660
 661   if (check_threshold)
 662     threshold = SCROLL_THRESHOLD;
 663   else
 664     threshold = 0;
 665   i = 0;
 666   while (i < win_info->generic.content_size - threshold
 667          && !is_displayed)
 668     {
 669       is_displayed
 670         = win_info->generic.content[i]
 671             ->which_element.source.line_or_addr.loa == LOA_ADDRESS
 672           && win_info->generic.content[i]
 673                ->which_element.source.line_or_addr.u.addr == addr;
 674       i++;
 675     }
 676
 677   return is_displayed;
 678 }
 679
 680
 681 /*****************************************
 682 ** STATIC LOCAL FUNCTIONS               **
 683 ******************************************/