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_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   tui_source_window_base *base = (tui_source_window_base *) win_info;
  79   base->horizontal_offset = 0;
  80   tui_update_source_window_as_is (win_info, gdbarch, s, line_or_addr, noerror);
  81
  82   return;
  83 }
  84
  85
  86 /* Function to display source in the source/asm window.  This function
  87    shows the source as specified by the horizontal offset.  */
  88 void
  89 tui_update_source_window_as_is (struct tui_win_info *win_info,
  90                                 struct gdbarch *gdbarch,
  91                                 struct symtab *s,
  92                                 struct tui_line_or_address line_or_addr,
  93                                 int noerror)
  94 {
  95   enum tui_status ret;
  96
  97   if (win_info->generic.type == SRC_WIN)
  98     ret = tui_set_source_content (s, line_or_addr.u.line_no, noerror);
  99   else
 100     ret = tui_set_disassem_content (gdbarch, line_or_addr.u.addr);
 101
 102   if (ret == TUI_FAILURE)
 103     {
 104       tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 105       tui_clear_exec_info_content (win_info);
 106     }
 107   else
 108     {
 109       tui_update_breakpoint_info (win_info, 0);
 110       tui_show_source_content (win_info);
 111       tui_update_exec_info (win_info);
 112       if (win_info->generic.type == SRC_WIN)
 113         {
 114           symtab_and_line sal;
 115
 116           sal.line = line_or_addr.u.line_no +
 117             (win_info->generic.content_size - 2);
 118           sal.symtab = s;
 119           sal.pspace = SYMTAB_PSPACE (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       for (struct tui_win_info *win_info : tui_source_windows ())
 164         {
 165           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 166           tui_clear_exec_info_content (win_info);
 167         }
 168     }
 169 }
 170
 171 /* Function to ensure that the source and/or disassemly windows
 172    reflect the input address.  */
 173 void
 174 tui_update_source_windows_with_line (struct symtab *s, int line)
 175 {
 176   struct gdbarch *gdbarch;
 177   CORE_ADDR pc;
 178   struct tui_line_or_address l;
 179
 180   if (!s)
 181     return;
 182
 183   gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
 184
 185   switch (tui_current_layout ())
 186     {
 187     case DISASSEM_COMMAND:
 188     case DISASSEM_DATA_COMMAND:
 189       find_line_pc (s, line, &pc);
 190       tui_update_source_windows_with_addr (gdbarch, pc);
 191       break;
 192     default:
 193       l.loa = LOA_LINE;
 194       l.u.line_no = line;
 195       tui_show_symtab_source (gdbarch, s, l, FALSE);
 196       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 197         {
 198           find_line_pc (s, line, &pc);
 199           tui_show_disassem (gdbarch, pc);
 200         }
 201       break;
 202     }
 203
 204   return;
 205 }
 206
 207 void
 208 tui_clear_source_content (struct tui_win_info *win_info,
 209                           int display_prompt)
 210 {
 211   if (win_info != NULL)
 212     {
 213       int i;
 214
 215       win_info->generic.content_in_use = FALSE;
 216       tui_erase_source_content (win_info, display_prompt);
 217       for (i = 0; i < win_info->generic.content_size; i++)
 218         {
 219           struct tui_win_element *element = win_info->generic.content[i];
 220
 221           element->which_element.source.has_break = FALSE;
 222           element->which_element.source.is_exec_point = FALSE;
 223         }
 224     }
 225 }
 226
 227
 228 void
 229 tui_erase_source_content (struct tui_win_info *win_info,
 230                           int display_prompt)
 231 {
 232   int x_pos;
 233   int half_width = (win_info->generic.width - 2) / 2;
 234
 235   if (win_info->generic.handle != NULL)
 236     {
 237       werase (win_info->generic.handle);
 238       tui_check_and_display_highlight_if_needed (win_info);
 239       if (display_prompt == EMPTY_SOURCE_PROMPT)
 240         {
 241           const char *no_src_str;
 242
 243           if (win_info->generic.type == SRC_WIN)
 244             no_src_str = NO_SRC_STRING;
 245           else
 246             no_src_str = NO_DISASSEM_STRING;
 247           if (strlen (no_src_str) >= half_width)
 248             x_pos = 1;
 249           else
 250             x_pos = half_width - strlen (no_src_str);
 251           mvwaddstr (win_info->generic.handle,
 252                      (win_info->generic.height / 2),
 253                      x_pos,
 254                      (char *) no_src_str);
 255
 256           /* elz: Added this function call to set the real contents of
 257              the window to what is on the screen, so that later calls
 258              to refresh, do display the correct stuff, and not the old
 259              image.  */
 260
 261           tui_set_source_content_nil (win_info, no_src_str);
 262         }
 263       tui_refresh_win (&win_info->generic);
 264     }
 265 }
 266
 267
 268 /* Redraw the complete line of a source or disassembly window.  */
 269 static void
 270 tui_show_source_line (struct tui_win_info *win_info, int lineno)
 271 {
 272   struct tui_win_element *line;
 273   int x;
 274
 275   line = win_info->generic.content[lineno - 1];
 276   if (line->which_element.source.is_exec_point)
 277     tui_set_reverse_mode (win_info->generic.handle, true);
 278
 279   wmove (win_info->generic.handle, lineno, 1);
 280   tui_puts (line->which_element.source.line,
 281             win_info->generic.handle);
 282   if (line->which_element.source.is_exec_point)
 283     tui_set_reverse_mode (win_info->generic.handle, false);
 284
 285   /* Clear to end of line but stop before the border.  */
 286   x = getcurx (win_info->generic.handle);
 287   while (x + 1 < win_info->generic.width)
 288     {
 289       waddch (win_info->generic.handle, ' ');
 290       x = getcurx (win_info->generic.handle);
 291     }
 292 }
 293
 294 void
 295 tui_show_source_content (struct tui_win_info *win_info)
 296 {
 297   if (win_info->generic.content_size > 0)
 298     {
 299       int lineno;
 300
 301       for (lineno = 1; lineno <= win_info->generic.content_size; lineno++)
 302         tui_show_source_line (win_info, lineno);
 303     }
 304   else
 305     tui_erase_source_content (win_info, TRUE);
 306
 307   tui_check_and_display_highlight_if_needed (win_info);
 308   tui_refresh_win (&win_info->generic);
 309   win_info->generic.content_in_use = TRUE;
 310 }
 311
 312 /* Refill the source window's source cache and update it.  If WIN_INFO
 313    is a disassembly window, then just update it.  */
 314
 315 void
 316 tui_refill_source_window (struct tui_win_info *win_info)
 317 {
 318   symtab *s = nullptr;
 319
 320   if (win_info->generic.type == SRC_WIN)
 321     {
 322       symtab_and_line cursal = get_current_source_symtab_and_line ();
 323       s = (cursal.symtab == NULL
 324            ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
 325            : cursal.symtab);
 326     }
 327
 328   tui_source_window_base *base = (tui_source_window_base *) win_info;
 329   tui_update_source_window_as_is (win_info,
 330                                   base->gdbarch,
 331                                   s,
 332                                   win_info->generic.content[0]
 333                                     ->which_element.source.line_or_addr,
 334                                   FALSE);
 335 }
 336
 337 /* Scroll the source forward or backward horizontally.  */
 338
 339 void
 340 tui_source_window_base::do_scroll_horizontal
 341   (enum tui_scroll_direction direction, int num_to_scroll)
 342 {
 343   if (generic.content != NULL)
 344     {
 345       int offset;
 346
 347       if (direction == LEFT_SCROLL)
 348         offset = horizontal_offset + num_to_scroll;
 349       else
 350         {
 351           offset = horizontal_offset - num_to_scroll;
 352           if (offset < 0)
 353             offset = 0;
 354         }
 355       horizontal_offset = offset;
 356       tui_refill_source_window (this);
 357     }
 358 }
 359
 360
 361 /* Set or clear the has_break flag in the line whose line is
 362    line_no.  */
 363
 364 void
 365 tui_set_is_exec_point_at (struct tui_line_or_address l,
 366                           struct tui_win_info *win_info)
 367 {
 368   int changed = 0;
 369   int i;
 370   tui_win_content content = win_info->generic.content;
 371
 372   i = 0;
 373   while (i < win_info->generic.content_size)
 374     {
 375       int new_state;
 376       struct tui_line_or_address content_loa =
 377         content[i]->which_element.source.line_or_addr;
 378
 379       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 380       gdb_assert (content_loa.loa == LOA_LINE
 381                   || content_loa.loa == LOA_ADDRESS);
 382       if (content_loa.loa == l.loa
 383           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 384               || (content_loa.u.addr == l.u.addr)))
 385         new_state = TRUE;
 386       else
 387         new_state = FALSE;
 388       if (new_state != content[i]->which_element.source.is_exec_point)
 389         {
 390           changed++;
 391           content[i]->which_element.source.is_exec_point = new_state;
 392           tui_show_source_line (win_info, i + 1);
 393         }
 394       i++;
 395     }
 396   if (changed)
 397     tui_refill_source_window (win_info);
 398 }
 399
 400 /* Update the execution windows to show the active breakpoints.
 401    This is called whenever a breakpoint is inserted, removed or
 402    has its state changed.  */
 403 void
 404 tui_update_all_breakpoint_info ()
 405 {
 406   for (tui_win_info *win : tui_source_windows ())
 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   tui_source_window_base *src = (tui_source_window_base *) win;
 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 = &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 != NULL;
 447            bp = bp->next)
 448         {
 449           struct bp_location *loc;
 450
 451           gdb_assert (line->line_or_addr.loa == LOA_LINE
 452                       || line->line_or_addr.loa == LOA_ADDRESS);
 453
 454           for (loc = bp->loc; loc != NULL; loc = loc->next)
 455             {
 456               if ((win == TUI_SRC_WIN
 457                    && loc->symtab != NULL
 458                    && filename_cmp (src->fullname,
 459                                     symtab_to_fullname (loc->symtab)) == 0
 460                    && line->line_or_addr.loa == LOA_LINE
 461                    && loc->line_number == line->line_or_addr.u.line_no)
 462                   || (win == TUI_DISASM_WIN
 463                       && line->line_or_addr.loa == LOA_ADDRESS
 464                       && loc->address == line->line_or_addr.u.addr))
 465                 {
 466                   if (bp->enable_state == bp_disabled)
 467                     mode |= TUI_BP_DISABLED;
 468                   else
 469                     mode |= TUI_BP_ENABLED;
 470                   if (bp->hit_count)
 471                     mode |= TUI_BP_HIT;
 472                   if (bp->loc->cond)
 473                     mode |= TUI_BP_CONDITIONAL;
 474                   if (bp->type == bp_hardware_breakpoint)
 475                     mode |= TUI_BP_HARDWARE;
 476                 }
 477             }
 478         }
 479       if (line->has_break != mode)
 480         {
 481           line->has_break = mode;
 482           need_refresh = 1;
 483         }
 484     }
 485   return need_refresh;
 486 }
 487
 488
 489 /* Function to initialize the content of the execution info window,
 490    based upon the input window which is either the source or
 491    disassembly window.  */
 492 enum tui_status
 493 tui_set_exec_info_content (struct tui_win_info *win_info)
 494 {
 495   enum tui_status ret = TUI_SUCCESS;
 496
 497   tui_source_window_base *base = (tui_source_window_base *) win_info;
 498   if (base->execution_info != NULL)
 499     {
 500       struct tui_gen_win_info *exec_info_ptr = base->execution_info;
 501
 502       if (exec_info_ptr->content == NULL)
 503         exec_info_ptr->content =
 504           tui_alloc_content (win_info->generic.height, exec_info_ptr->type);
 505       if (exec_info_ptr->content != NULL)
 506         {
 507           int i;
 508
 509           tui_update_breakpoint_info (win_info, 1);
 510           for (i = 0; i < win_info->generic.content_size; i++)
 511             {
 512               struct tui_win_element *element;
 513               struct tui_win_element *src_element;
 514               int mode;
 515
 516               element = exec_info_ptr->content[i];
 517               src_element = win_info->generic.content[i];
 518
 519               memset(element->which_element.simple_string, ' ',
 520                      sizeof(element->which_element.simple_string));
 521               element->which_element.simple_string[TUI_EXECINFO_SIZE - 1] = 0;
 522
 523               /* Now update the exec info content based upon the state
 524                  of each line as indicated by the source content.  */
 525               mode = src_element->which_element.source.has_break;
 526               if (mode & TUI_BP_HIT)
 527                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 528                   (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 529               else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 530                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 531                   (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 532
 533               if (mode & TUI_BP_ENABLED)
 534                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
 535               else if (mode & TUI_BP_DISABLED)
 536                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
 537
 538               if (src_element->which_element.source.is_exec_point)
 539                 element->which_element.simple_string[TUI_EXEC_POS] = '>';
 540             }
 541           exec_info_ptr->content_size = win_info->generic.content_size;
 542         }
 543       else
 544         ret = TUI_FAILURE;
 545     }
 546
 547   return ret;
 548 }
 549
 550
 551 void
 552 tui_show_exec_info_content (struct tui_win_info *win_info)
 553 {
 554   tui_source_window_base *base = (tui_source_window_base *) win_info;
 555   struct tui_gen_win_info *exec_info = base->execution_info;
 556   int cur_line;
 557
 558   werase (exec_info->handle);
 559   tui_refresh_win (exec_info);
 560   for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
 561     mvwaddstr (exec_info->handle,
 562                cur_line,
 563                0,
 564                (char *) exec_info->content[cur_line - 1]
 565                           ->which_element.simple_string);
 566   tui_refresh_win (exec_info);
 567   exec_info->content_in_use = TRUE;
 568 }
 569
 570
 571 void
 572 tui_erase_exec_info_content (struct tui_win_info *win_info)
 573 {
 574   tui_source_window_base *base = (tui_source_window_base *) win_info;
 575   struct tui_gen_win_info *exec_info = base->execution_info;
 576
 577   werase (exec_info->handle);
 578   tui_refresh_win (exec_info);
 579 }
 580
 581 void
 582 tui_clear_exec_info_content (struct tui_win_info *win_info)
 583 {
 584   tui_source_window_base *base = (tui_source_window_base *) win_info;
 585   base->execution_info->content_in_use = FALSE;
 586   tui_erase_exec_info_content (win_info);
 587
 588   return;
 589 }
 590
 591 /* Function to update the execution info window.  */
 592 void
 593 tui_update_exec_info (struct tui_win_info *win_info)
 594 {
 595   tui_set_exec_info_content (win_info);
 596   tui_show_exec_info_content (win_info);
 597 }
 598
 599 enum tui_status
 600 tui_alloc_source_buffer (struct tui_win_info *win_info)
 601 {
 602   int i, line_width, max_lines;
 603
 604   /* The window width/height includes the highlight box.  Determine actual
 605      content dimensions, including string null-terminators.  */
 606   max_lines = win_info->generic.height - 2;
 607   line_width = win_info->generic.width - 2 + 1;
 608
 609   /* Allocate the buffer for the source lines.  */
 610   if (win_info->generic.content == NULL)
 611     {
 612       /* Allocate the content list.  */
 613       win_info->generic.content = tui_alloc_content (max_lines, SRC_WIN);
 614       for (i = 0; i < max_lines; i++)
 615         win_info->generic.content[i]->which_element.source.line
 616           = (char *) xmalloc (line_width);
 617     }
 618
 619   return TUI_SUCCESS;
 620 }
 621
 622
 623 /* Answer whether a particular line number or address is displayed
 624    in the current source window.  */
 625 int
 626 tui_line_is_displayed (int line,
 627                        struct tui_win_info *win_info,
 628                        int check_threshold)
 629 {
 630   int is_displayed = FALSE;
 631   int i, threshold;
 632
 633   if (check_threshold)
 634     threshold = SCROLL_THRESHOLD;
 635   else
 636     threshold = 0;
 637   i = 0;
 638   while (i < win_info->generic.content_size - threshold
 639          && !is_displayed)
 640     {
 641       is_displayed
 642         = win_info->generic.content[i]
 643             ->which_element.source.line_or_addr.loa == LOA_LINE
 644           && win_info->generic.content[i]
 645                ->which_element.source.line_or_addr.u.line_no == line;
 646       i++;
 647     }
 648
 649   return is_displayed;
 650 }
 651
 652
 653 /* Answer whether a particular line number or address is displayed
 654    in the current source window.  */
 655 int
 656 tui_addr_is_displayed (CORE_ADDR addr,
 657                        struct tui_win_info *win_info,
 658                        int check_threshold)
 659 {
 660   int is_displayed = FALSE;
 661   int i, threshold;
 662
 663   if (check_threshold)
 664     threshold = SCROLL_THRESHOLD;
 665   else
 666     threshold = 0;
 667   i = 0;
 668   while (i < win_info->generic.content_size - threshold
 669          && !is_displayed)
 670     {
 671       is_displayed
 672         = win_info->generic.content[i]
 673             ->which_element.source.line_or_addr.loa == LOA_ADDRESS
 674           && win_info->generic.content[i]
 675                ->which_element.source.line_or_addr.u.addr == addr;
 676       i++;
 677     }
 678
 679   return is_displayed;
 680 }
 681
 682
 683 /*****************************************
 684 ** STATIC LOCAL FUNCTIONS               **
 685 ******************************************/