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 ()
  46 {
  47   if (!tui_source_windows ().empty ())
  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_source_window_base *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->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_source_window_base *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->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->type == SRC_WIN)
 112         {
 113           symtab_and_line sal;
 114
 115           sal.line = line_or_addr.u.line_no +
 116             (win_info->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       for (struct tui_source_window_base *win_info : tui_source_windows ())
 163         {
 164           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 165           tui_clear_exec_info_content (win_info);
 166         }
 167     }
 168 }
 169
 170 /* Function to ensure that the source and/or disassemly windows
 171    reflect the input address.  */
 172 void
 173 tui_update_source_windows_with_line (struct symtab *s, int line)
 174 {
 175   struct gdbarch *gdbarch;
 176   CORE_ADDR pc;
 177   struct tui_line_or_address l;
 178
 179   if (!s)
 180     return;
 181
 182   gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
 183
 184   switch (tui_current_layout ())
 185     {
 186     case DISASSEM_COMMAND:
 187     case DISASSEM_DATA_COMMAND:
 188       find_line_pc (s, line, &pc);
 189       tui_update_source_windows_with_addr (gdbarch, pc);
 190       break;
 191     default:
 192       l.loa = LOA_LINE;
 193       l.u.line_no = line;
 194       tui_show_symtab_source (gdbarch, s, l, FALSE);
 195       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 196         {
 197           find_line_pc (s, line, &pc);
 198           tui_show_disassem (gdbarch, pc);
 199         }
 200       break;
 201     }
 202
 203   return;
 204 }
 205
 206 void
 207 tui_clear_source_content (struct tui_win_info *win_info,
 208                           int display_prompt)
 209 {
 210   if (win_info != NULL)
 211     {
 212       int i;
 213
 214       win_info->content_in_use = FALSE;
 215       tui_erase_source_content (win_info, display_prompt);
 216       for (i = 0; i < win_info->content_size; i++)
 217         {
 218           struct tui_win_element *element = win_info->content[i];
 219
 220           element->which_element.source.has_break = FALSE;
 221           element->which_element.source.is_exec_point = FALSE;
 222         }
 223     }
 224 }
 225
 226
 227 void
 228 tui_erase_source_content (struct tui_win_info *win_info,
 229                           int display_prompt)
 230 {
 231   int x_pos;
 232   int half_width = (win_info->width - 2) / 2;
 233
 234   if (win_info->handle != NULL)
 235     {
 236       werase (win_info->handle);
 237       tui_check_and_display_highlight_if_needed (win_info);
 238       if (display_prompt == EMPTY_SOURCE_PROMPT)
 239         {
 240           const char *no_src_str;
 241
 242           if (win_info->type == SRC_WIN)
 243             no_src_str = NO_SRC_STRING;
 244           else
 245             no_src_str = NO_DISASSEM_STRING;
 246           if (strlen (no_src_str) >= half_width)
 247             x_pos = 1;
 248           else
 249             x_pos = half_width - strlen (no_src_str);
 250           mvwaddstr (win_info->handle,
 251                      (win_info->height / 2),
 252                      x_pos,
 253                      (char *) no_src_str);
 254
 255           /* elz: Added this function call to set the real contents of
 256              the window to what is on the screen, so that later calls
 257              to refresh, do display the correct stuff, and not the old
 258              image.  */
 259
 260           tui_set_source_content_nil (win_info, no_src_str);
 261         }
 262       win_info->refresh_window ();
 263     }
 264 }
 265
 266
 267 /* Redraw the complete line of a source or disassembly window.  */
 268 static void
 269 tui_show_source_line (struct tui_win_info *win_info, int lineno)
 270 {
 271   struct tui_win_element *line;
 272   int x;
 273
 274   line = win_info->content[lineno - 1];
 275   if (line->which_element.source.is_exec_point)
 276     tui_set_reverse_mode (win_info->handle, true);
 277
 278   wmove (win_info->handle, lineno, 1);
 279   tui_puts (line->which_element.source.line,
 280             win_info->handle);
 281   if (line->which_element.source.is_exec_point)
 282     tui_set_reverse_mode (win_info->handle, false);
 283
 284   /* Clear to end of line but stop before the border.  */
 285   x = getcurx (win_info->handle);
 286   while (x + 1 < win_info->width)
 287     {
 288       waddch (win_info->handle, ' ');
 289       x = getcurx (win_info->handle);
 290     }
 291 }
 292
 293 void
 294 tui_show_source_content (struct tui_win_info *win_info)
 295 {
 296   if (win_info->content_size > 0)
 297     {
 298       int lineno;
 299
 300       for (lineno = 1; lineno <= win_info->content_size; lineno++)
 301         tui_show_source_line (win_info, lineno);
 302     }
 303   else
 304     tui_erase_source_content (win_info, TRUE);
 305
 306   tui_check_and_display_highlight_if_needed (win_info);
 307   win_info->refresh_window ();
 308   win_info->content_in_use = TRUE;
 309 }
 310
 311 /* See tui-data.h.  */
 312
 313 void
 314 tui_source_window_base::refill ()
 315 {
 316   symtab *s = nullptr;
 317
 318   if (type == SRC_WIN)
 319     {
 320       symtab_and_line cursal = get_current_source_symtab_and_line ();
 321       s = (cursal.symtab == NULL
 322            ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
 323            : cursal.symtab);
 324     }
 325
 326   tui_update_source_window_as_is (this, gdbarch, s,
 327                                   content[0]
 328                                     ->which_element.source.line_or_addr,
 329                                   FALSE);
 330 }
 331
 332 /* Scroll the source forward or backward horizontally.  */
 333
 334 void
 335 tui_source_window_base::do_scroll_horizontal
 336   (enum tui_scroll_direction direction, int num_to_scroll)
 337 {
 338   if (content != NULL)
 339     {
 340       int offset;
 341
 342       if (direction == LEFT_SCROLL)
 343         offset = horizontal_offset + num_to_scroll;
 344       else
 345         {
 346           offset = horizontal_offset - num_to_scroll;
 347           if (offset < 0)
 348             offset = 0;
 349         }
 350       horizontal_offset = offset;
 351       refill ();
 352     }
 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_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
 361 {
 362   int changed = 0;
 363   int i;
 364
 365   i = 0;
 366   while (i < 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 (this, i + 1);
 386         }
 387       i++;
 388     }
 389   if (changed)
 390     refill ();
 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 ()
 398 {
 399   for (tui_source_window_base *win : tui_source_windows ())
 400     {
 401       if (tui_update_breakpoint_info (win, FALSE))
 402         {
 403           tui_update_exec_info (win);
 404         }
 405     }
 406 }
 407
 408
 409 /* Scan the source window and the breakpoints to update the has_break
 410    information for each line.
 411
 412    Returns 1 if something changed and the execution window must be
 413    refreshed.  */
 414
 415 int
 416 tui_update_breakpoint_info (struct tui_win_info *win,
 417                             int current_only)
 418 {
 419   int i;
 420   int need_refresh = 0;
 421   tui_source_window_base *src = (tui_source_window_base *) win;
 422
 423   for (i = 0; i < win->content_size; i++)
 424     {
 425       struct breakpoint *bp;
 426       extern struct breakpoint *breakpoint_chain;
 427       int mode;
 428       struct tui_source_element *line;
 429
 430       line = &win->content[i]->which_element.source;
 431       if (current_only && !line->is_exec_point)
 432          continue;
 433
 434       /* Scan each breakpoint to see if the current line has something to
 435          do with it.  Identify enable/disabled breakpoints as well as
 436          those that we already hit.  */
 437       mode = 0;
 438       for (bp = breakpoint_chain;
 439            bp != NULL;
 440            bp = bp->next)
 441         {
 442           struct bp_location *loc;
 443
 444           gdb_assert (line->line_or_addr.loa == LOA_LINE
 445                       || line->line_or_addr.loa == LOA_ADDRESS);
 446
 447           for (loc = bp->loc; loc != NULL; loc = loc->next)
 448             {
 449               if ((win == TUI_SRC_WIN
 450                    && loc->symtab != NULL
 451                    && filename_cmp (src->fullname,
 452                                     symtab_to_fullname (loc->symtab)) == 0
 453                    && line->line_or_addr.loa == LOA_LINE
 454                    && loc->line_number == line->line_or_addr.u.line_no)
 455                   || (win == TUI_DISASM_WIN
 456                       && line->line_or_addr.loa == LOA_ADDRESS
 457                       && loc->address == line->line_or_addr.u.addr))
 458                 {
 459                   if (bp->enable_state == bp_disabled)
 460                     mode |= TUI_BP_DISABLED;
 461                   else
 462                     mode |= TUI_BP_ENABLED;
 463                   if (bp->hit_count)
 464                     mode |= TUI_BP_HIT;
 465                   if (bp->loc->cond)
 466                     mode |= TUI_BP_CONDITIONAL;
 467                   if (bp->type == bp_hardware_breakpoint)
 468                     mode |= TUI_BP_HARDWARE;
 469                 }
 470             }
 471         }
 472       if (line->has_break != mode)
 473         {
 474           line->has_break = mode;
 475           need_refresh = 1;
 476         }
 477     }
 478   return need_refresh;
 479 }
 480
 481
 482 /* Function to initialize the content of the execution info window,
 483    based upon the input window which is either the source or
 484    disassembly window.  */
 485 enum tui_status
 486 tui_set_exec_info_content (struct tui_win_info *win_info)
 487 {
 488   enum tui_status ret = TUI_SUCCESS;
 489
 490   tui_source_window_base *base = (tui_source_window_base *) win_info;
 491   if (base->execution_info != NULL)
 492     {
 493       struct tui_gen_win_info *exec_info_ptr = base->execution_info;
 494
 495       if (exec_info_ptr->content == NULL)
 496         exec_info_ptr->content =
 497           tui_alloc_content (win_info->height, exec_info_ptr->type);
 498
 499       tui_update_breakpoint_info (win_info, 1);
 500       for (int i = 0; i < win_info->content_size; i++)
 501         {
 502           struct tui_win_element *element;
 503           struct tui_win_element *src_element;
 504           int mode;
 505
 506           element = exec_info_ptr->content[i];
 507           src_element = win_info->content[i];
 508
 509           memset(element->which_element.simple_string, ' ',
 510                  sizeof(element->which_element.simple_string));
 511           element->which_element.simple_string[TUI_EXECINFO_SIZE - 1] = 0;
 512
 513           /* Now update the exec info content based upon the state
 514              of each line as indicated by the source content.  */
 515           mode = src_element->which_element.source.has_break;
 516           if (mode & TUI_BP_HIT)
 517             element->which_element.simple_string[TUI_BP_HIT_POS] =
 518               (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 519           else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 520             element->which_element.simple_string[TUI_BP_HIT_POS] =
 521               (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 522
 523           if (mode & TUI_BP_ENABLED)
 524             element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
 525           else if (mode & TUI_BP_DISABLED)
 526             element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
 527
 528           if (src_element->which_element.source.is_exec_point)
 529             element->which_element.simple_string[TUI_EXEC_POS] = '>';
 530         }
 531       exec_info_ptr->content_size = win_info->content_size;
 532     }
 533
 534   return ret;
 535 }
 536
 537
 538 void
 539 tui_show_exec_info_content (struct tui_win_info *win_info)
 540 {
 541   tui_source_window_base *base = (tui_source_window_base *) win_info;
 542   struct tui_gen_win_info *exec_info = base->execution_info;
 543   int cur_line;
 544
 545   werase (exec_info->handle);
 546   exec_info->refresh_window ();
 547   for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
 548     mvwaddstr (exec_info->handle,
 549                cur_line,
 550                0,
 551                (char *) exec_info->content[cur_line - 1]
 552                           ->which_element.simple_string);
 553   exec_info->refresh_window ();
 554   exec_info->content_in_use = TRUE;
 555 }
 556
 557
 558 void
 559 tui_erase_exec_info_content (struct tui_win_info *win_info)
 560 {
 561   tui_source_window_base *base = (tui_source_window_base *) win_info;
 562   struct tui_gen_win_info *exec_info = base->execution_info;
 563
 564   werase (exec_info->handle);
 565   exec_info->refresh_window ();
 566 }
 567
 568 void
 569 tui_clear_exec_info_content (struct tui_win_info *win_info)
 570 {
 571   tui_source_window_base *base = (tui_source_window_base *) win_info;
 572   base->execution_info->content_in_use = FALSE;
 573   tui_erase_exec_info_content (win_info);
 574
 575   return;
 576 }
 577
 578 /* Function to update the execution info window.  */
 579 void
 580 tui_update_exec_info (struct tui_win_info *win_info)
 581 {
 582   tui_set_exec_info_content (win_info);
 583   tui_show_exec_info_content (win_info);
 584 }
 585
 586 void
 587 tui_alloc_source_buffer (struct tui_win_info *win_info)
 588 {
 589   int i, line_width, max_lines;
 590
 591   /* The window width/height includes the highlight box.  Determine actual
 592      content dimensions, including string null-terminators.  */
 593   max_lines = win_info->height - 2;
 594   line_width = win_info->width - 2 + 1;
 595
 596   /* Allocate the buffer for the source lines.  */
 597   if (win_info->content == NULL)
 598     {
 599       /* Allocate the content list.  */
 600       win_info->content = tui_alloc_content (max_lines, SRC_WIN);
 601       for (i = 0; i < max_lines; i++)
 602         win_info->content[i]->which_element.source.line
 603           = (char *) xmalloc (line_width);
 604     }
 605 }
 606
 607
 608 /* Answer whether a particular line number or address is displayed
 609    in the current source window.  */
 610 int
 611 tui_line_is_displayed (int line,
 612                        struct tui_win_info *win_info,
 613                        int check_threshold)
 614 {
 615   int is_displayed = FALSE;
 616   int i, threshold;
 617
 618   if (check_threshold)
 619     threshold = SCROLL_THRESHOLD;
 620   else
 621     threshold = 0;
 622   i = 0;
 623   while (i < win_info->content_size - threshold
 624          && !is_displayed)
 625     {
 626       is_displayed
 627         = win_info->content[i]
 628             ->which_element.source.line_or_addr.loa == LOA_LINE
 629           && win_info->content[i]
 630                ->which_element.source.line_or_addr.u.line_no == line;
 631       i++;
 632     }
 633
 634   return is_displayed;
 635 }
 636
 637
 638 /* Answer whether a particular line number or address is displayed
 639    in the current source window.  */
 640 int
 641 tui_addr_is_displayed (CORE_ADDR addr,
 642                        struct tui_win_info *win_info,
 643                        int check_threshold)
 644 {
 645   int is_displayed = FALSE;
 646   int i, threshold;
 647
 648   if (check_threshold)
 649     threshold = SCROLL_THRESHOLD;
 650   else
 651     threshold = 0;
 652   i = 0;
 653   while (i < win_info->content_size - threshold
 654          && !is_displayed)
 655     {
 656       is_displayed
 657         = win_info->content[i]
 658             ->which_element.source.line_or_addr.loa == LOA_ADDRESS
 659           && win_info->content[i]
 660                ->which_element.source.line_or_addr.u.addr == addr;
 661       i++;
 662     }
 663
 664   return is_displayed;
 665 }
 666
 667
 668 /*****************************************
 669 ** STATIC LOCAL FUNCTIONS               **
 670 ******************************************/