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 /* Refill the source window's source cache and update it.  If WIN_INFO
 310    is a disassembly window, then just update it.  */
 311
 312 void
 313 tui_refill_source_window (struct tui_win_info *win_info)
 314 {
 315   symtab *s = nullptr;
 316
 317   if (win_info->generic.type == SRC_WIN)
 318     {
 319       symtab_and_line cursal = get_current_source_symtab_and_line ();
 320       s = (cursal.symtab == NULL
 321            ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
 322            : cursal.symtab);
 323     }
 324
 325   tui_update_source_window_as_is (win_info,
 326                                   win_info->detail.source_info.gdbarch,
 327                                   s,
 328                                   win_info->generic.content[0]
 329                                     ->which_element.source.line_or_addr,
 330                                   FALSE);
 331 }
 332
 333 /* Scroll the source forward or backward horizontally.  */
 334
 335 void
 336 tui_horizontal_source_scroll (struct tui_win_info *win_info,
 337                               enum tui_scroll_direction direction,
 338                               int num_to_scroll)
 339 {
 340   if (win_info->generic.content != NULL)
 341     {
 342       int offset;
 343
 344       if (direction == LEFT_SCROLL)
 345         offset = win_info->detail.source_info.horizontal_offset
 346           + num_to_scroll;
 347       else
 348         {
 349           offset = win_info->detail.source_info.horizontal_offset
 350             - num_to_scroll;
 351           if (offset < 0)
 352             offset = 0;
 353         }
 354       win_info->detail.source_info.horizontal_offset = offset;
 355       tui_refill_source_window (win_info);
 356     }
 357 }
 358
 359
 360 /* Set or clear the has_break flag in the line whose line is
 361    line_no.  */
 362
 363 void
 364 tui_set_is_exec_point_at (struct tui_line_or_address l,
 365                           struct tui_win_info *win_info)
 366 {
 367   int changed = 0;
 368   int i;
 369   tui_win_content content = win_info->generic.content;
 370
 371   i = 0;
 372   while (i < win_info->generic.content_size)
 373     {
 374       int new_state;
 375       struct tui_line_or_address content_loa =
 376         content[i]->which_element.source.line_or_addr;
 377
 378       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 379       gdb_assert (content_loa.loa == LOA_LINE
 380                   || content_loa.loa == LOA_ADDRESS);
 381       if (content_loa.loa == l.loa
 382           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 383               || (content_loa.u.addr == l.u.addr)))
 384         new_state = TRUE;
 385       else
 386         new_state = FALSE;
 387       if (new_state != content[i]->which_element.source.is_exec_point)
 388         {
 389           changed++;
 390           content[i]->which_element.source.is_exec_point = new_state;
 391           tui_show_source_line (win_info, i + 1);
 392         }
 393       i++;
 394     }
 395   if (changed)
 396     tui_refresh_win (&win_info->generic);
 397 }
 398
 399 /* Update the execution windows to show the active breakpoints.
 400    This is called whenever a breakpoint is inserted, removed or
 401    has its state changed.  */
 402 void
 403 tui_update_all_breakpoint_info (void)
 404 {
 405   struct tui_list *list = tui_source_windows ();
 406   int i;
 407
 408   for (i = 0; i < list->count; i++)
 409     {
 410       struct tui_win_info *win = list->list[i];
 411
 412       if (tui_update_breakpoint_info (win, FALSE))
 413         {
 414           tui_update_exec_info (win);
 415         }
 416     }
 417 }
 418
 419
 420 /* Scan the source window and the breakpoints to update the has_break
 421    information for each line.
 422
 423    Returns 1 if something changed and the execution window must be
 424    refreshed.  */
 425
 426 int
 427 tui_update_breakpoint_info (struct tui_win_info *win,
 428                             int current_only)
 429 {
 430   int i;
 431   int need_refresh = 0;
 432   struct tui_source_info *src = &win->detail.source_info;
 433
 434   for (i = 0; i < win->generic.content_size; i++)
 435     {
 436       struct breakpoint *bp;
 437       extern struct breakpoint *breakpoint_chain;
 438       int mode;
 439       struct tui_source_element *line;
 440
 441       line = &win->generic.content[i]->which_element.source;
 442       if (current_only && !line->is_exec_point)
 443          continue;
 444
 445       /* Scan each breakpoint to see if the current line has something to
 446          do with it.  Identify enable/disabled breakpoints as well as
 447          those that we already hit.  */
 448       mode = 0;
 449       for (bp = breakpoint_chain;
 450            bp != (struct breakpoint *) NULL;
 451            bp = bp->next)
 452         {
 453           struct bp_location *loc;
 454
 455           gdb_assert (line->line_or_addr.loa == LOA_LINE
 456                       || line->line_or_addr.loa == LOA_ADDRESS);
 457
 458           for (loc = bp->loc; loc != NULL; loc = loc->next)
 459             {
 460               if ((win == TUI_SRC_WIN
 461                    && loc->symtab != NULL
 462                    && filename_cmp (src->fullname,
 463                                     symtab_to_fullname (loc->symtab)) == 0
 464                    && line->line_or_addr.loa == LOA_LINE
 465                    && loc->line_number == line->line_or_addr.u.line_no)
 466                   || (win == TUI_DISASM_WIN
 467                       && line->line_or_addr.loa == LOA_ADDRESS
 468                       && loc->address == line->line_or_addr.u.addr))
 469                 {
 470                   if (bp->enable_state == bp_disabled)
 471                     mode |= TUI_BP_DISABLED;
 472                   else
 473                     mode |= TUI_BP_ENABLED;
 474                   if (bp->hit_count)
 475                     mode |= TUI_BP_HIT;
 476                   if (bp->loc->cond)
 477                     mode |= TUI_BP_CONDITIONAL;
 478                   if (bp->type == bp_hardware_breakpoint)
 479                     mode |= TUI_BP_HARDWARE;
 480                 }
 481             }
 482         }
 483       if (line->has_break != mode)
 484         {
 485           line->has_break = mode;
 486           need_refresh = 1;
 487         }
 488     }
 489   return need_refresh;
 490 }
 491
 492
 493 /* Function to initialize the content of the execution info window,
 494    based upon the input window which is either the source or
 495    disassembly window.  */
 496 enum tui_status
 497 tui_set_exec_info_content (struct tui_win_info *win_info)
 498 {
 499   enum tui_status ret = TUI_SUCCESS;
 500
 501   if (win_info->detail.source_info.execution_info
 502       != (struct tui_gen_win_info *) NULL)
 503     {
 504       struct tui_gen_win_info *exec_info_ptr
 505         = win_info->detail.source_info.execution_info;
 506
 507       if (exec_info_ptr->content == NULL)
 508         exec_info_ptr->content =
 509           tui_alloc_content (win_info->generic.height, exec_info_ptr->type);
 510       if (exec_info_ptr->content != NULL)
 511         {
 512           int i;
 513
 514           tui_update_breakpoint_info (win_info, 1);
 515           for (i = 0; i < win_info->generic.content_size; i++)
 516             {
 517               struct tui_win_element *element;
 518               struct tui_win_element *src_element;
 519               int mode;
 520
 521               element = exec_info_ptr->content[i];
 522               src_element = win_info->generic.content[i];
 523
 524               memset(element->which_element.simple_string, ' ',
 525                      sizeof(element->which_element.simple_string));
 526               element->which_element.simple_string[TUI_EXECINFO_SIZE - 1] = 0;
 527
 528               /* Now update the exec info content based upon the state
 529                  of each line as indicated by the source content.  */
 530               mode = src_element->which_element.source.has_break;
 531               if (mode & TUI_BP_HIT)
 532                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 533                   (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 534               else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 535                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 536                   (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 537
 538               if (mode & TUI_BP_ENABLED)
 539                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
 540               else if (mode & TUI_BP_DISABLED)
 541                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
 542
 543               if (src_element->which_element.source.is_exec_point)
 544                 element->which_element.simple_string[TUI_EXEC_POS] = '>';
 545             }
 546           exec_info_ptr->content_size = win_info->generic.content_size;
 547         }
 548       else
 549         ret = TUI_FAILURE;
 550     }
 551
 552   return ret;
 553 }
 554
 555
 556 void
 557 tui_show_exec_info_content (struct tui_win_info *win_info)
 558 {
 559   struct tui_gen_win_info *exec_info
 560     = win_info->detail.source_info.execution_info;
 561   int cur_line;
 562
 563   werase (exec_info->handle);
 564   tui_refresh_win (exec_info);
 565   for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
 566     mvwaddstr (exec_info->handle,
 567                cur_line,
 568                0,
 569                (char *) exec_info->content[cur_line - 1]
 570                           ->which_element.simple_string);
 571   tui_refresh_win (exec_info);
 572   exec_info->content_in_use = TRUE;
 573 }
 574
 575
 576 void
 577 tui_erase_exec_info_content (struct tui_win_info *win_info)
 578 {
 579   struct tui_gen_win_info *exec_info
 580     = win_info->detail.source_info.execution_info;
 581
 582   werase (exec_info->handle);
 583   tui_refresh_win (exec_info);
 584 }
 585
 586 void
 587 tui_clear_exec_info_content (struct tui_win_info *win_info)
 588 {
 589   win_info->detail.source_info.execution_info->content_in_use = FALSE;
 590   tui_erase_exec_info_content (win_info);
 591
 592   return;
 593 }
 594
 595 /* Function to update the execution info window.  */
 596 void
 597 tui_update_exec_info (struct tui_win_info *win_info)
 598 {
 599   tui_set_exec_info_content (win_info);
 600   tui_show_exec_info_content (win_info);
 601 }
 602
 603 enum tui_status
 604 tui_alloc_source_buffer (struct tui_win_info *win_info)
 605 {
 606   int i, line_width, max_lines;
 607
 608   /* The window width/height includes the highlight box.  Determine actual
 609      content dimensions, including string null-terminators.  */
 610   max_lines = win_info->generic.height - 2;
 611   line_width = win_info->generic.width - 2 + 1;
 612
 613   /* Allocate the buffer for the source lines.  */
 614   if (win_info->generic.content == NULL)
 615     {
 616       /* Allocate the content list.  */
 617       win_info->generic.content = tui_alloc_content (max_lines, SRC_WIN);
 618       for (i = 0; i < max_lines; i++)
 619         win_info->generic.content[i]->which_element.source.line
 620           = (char *) xmalloc (line_width);
 621     }
 622
 623   return TUI_SUCCESS;
 624 }
 625
 626
 627 /* Answer whether a particular line number or address is displayed
 628    in the current source window.  */
 629 int
 630 tui_line_is_displayed (int line,
 631                        struct tui_win_info *win_info,
 632                        int check_threshold)
 633 {
 634   int is_displayed = FALSE;
 635   int i, threshold;
 636
 637   if (check_threshold)
 638     threshold = SCROLL_THRESHOLD;
 639   else
 640     threshold = 0;
 641   i = 0;
 642   while (i < win_info->generic.content_size - threshold
 643          && !is_displayed)
 644     {
 645       is_displayed
 646         = win_info->generic.content[i]
 647             ->which_element.source.line_or_addr.loa == LOA_LINE
 648           && win_info->generic.content[i]
 649                ->which_element.source.line_or_addr.u.line_no == line;
 650       i++;
 651     }
 652
 653   return is_displayed;
 654 }
 655
 656
 657 /* Answer whether a particular line number or address is displayed
 658    in the current source window.  */
 659 int
 660 tui_addr_is_displayed (CORE_ADDR addr,
 661                        struct tui_win_info *win_info,
 662                        int check_threshold)
 663 {
 664   int is_displayed = FALSE;
 665   int i, threshold;
 666
 667   if (check_threshold)
 668     threshold = SCROLL_THRESHOLD;
 669   else
 670     threshold = 0;
 671   i = 0;
 672   while (i < win_info->generic.content_size - threshold
 673          && !is_displayed)
 674     {
 675       is_displayed
 676         = win_info->generic.content[i]
 677             ->which_element.source.line_or_addr.loa == LOA_ADDRESS
 678           && win_info->generic.content[i]
 679                ->which_element.source.line_or_addr.u.addr == addr;
 680       i++;
 681     }
 682
 683   return is_displayed;
 684 }
 685
 686
 687 /*****************************************
 688 ** STATIC LOCAL FUNCTIONS               **
 689 ******************************************/