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