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 (win_info, s, line_or_addr.u.line_no,
  98                                   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, nullptr, false);
 110       tui_show_source_content (win_info);
 111       tui_update_exec_info (win_info);
 112       if (win_info->type == SRC_WIN)
 113         {
 114           symtab_and_line sal;
 115
 116           sal.line = line_or_addr.u.line_no +
 117             (win_info->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 (win_info);
 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 (TUI_SRC_WIN, 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 (TUI_SRC_WIN, 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_source_window_base *win_info,
 209                           int display_prompt)
 210 {
 211   if (win_info != NULL)
 212     {
 213       int i;
 214
 215       win_info->content_in_use = FALSE;
 216       tui_erase_source_content (win_info, display_prompt);
 217       for (i = 0; i < win_info->content.size (); i++)
 218         {
 219           struct tui_source_element *element = &win_info->content[i];
 220
 221           element->break_mode = 0;
 222           element->is_exec_point = false;
 223         }
 224     }
 225 }
 226
 227
 228 void
 229 tui_erase_source_content (struct tui_source_window_base *win_info,
 230                           int display_prompt)
 231 {
 232   int x_pos;
 233   int half_width = (win_info->width - 2) / 2;
 234
 235   if (win_info->handle != NULL)
 236     {
 237       werase (win_info->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->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->handle,
 252                      (win_info->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       win_info->refresh_window ();
 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_source_window_base *win_info, int lineno)
 271 {
 272   struct tui_source_element *line;
 273   int x;
 274
 275   line = &win_info->content[lineno - 1];
 276   if (line->is_exec_point)
 277     tui_set_reverse_mode (win_info->handle, true);
 278
 279   wmove (win_info->handle, lineno, 1);
 280   tui_puts (line->line,
 281             win_info->handle);
 282   if (line->is_exec_point)
 283     tui_set_reverse_mode (win_info->handle, false);
 284
 285   /* Clear to end of line but stop before the border.  */
 286   x = getcurx (win_info->handle);
 287   while (x + 1 < win_info->width)
 288     {
 289       waddch (win_info->handle, ' ');
 290       x = getcurx (win_info->handle);
 291     }
 292 }
 293
 294 void
 295 tui_show_source_content (struct tui_source_window_base *win_info)
 296 {
 297   if (!win_info->content.empty ())
 298     {
 299       int lineno;
 300
 301       for (lineno = 1; lineno <= win_info->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   win_info->refresh_window ();
 309   win_info->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 (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                                   content[0].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 (int num_to_scroll)
 336 {
 337   if (!content.empty ())
 338     {
 339       int offset = horizontal_offset + num_to_scroll;
 340       if (offset < 0)
 341         offset = 0;
 342       horizontal_offset = offset;
 343       refill ();
 344     }
 345 }
 346
 347
 348 /* Set or clear the is_exec_point flag in the line whose line is
 349    line_no.  */
 350
 351 void
 352 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
 353 {
 354   bool changed = false;
 355   int i;
 356
 357   i = 0;
 358   while (i < content.size ())
 359     {
 360       bool new_state;
 361       struct tui_line_or_address content_loa =
 362         content[i].line_or_addr;
 363
 364       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 365       gdb_assert (content_loa.loa == LOA_LINE
 366                   || content_loa.loa == LOA_ADDRESS);
 367       if (content_loa.loa == l.loa
 368           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 369               || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
 370         new_state = true;
 371       else
 372         new_state = false;
 373       if (new_state != content[i].is_exec_point)
 374         {
 375           changed = true;
 376           content[i].is_exec_point = new_state;
 377           tui_show_source_line (this, i + 1);
 378         }
 379       i++;
 380     }
 381   if (changed)
 382     refill ();
 383 }
 384
 385 /* See tui-winsource.h.  */
 386
 387 void
 388 tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
 389 {
 390   for (tui_source_window_base *win : tui_source_windows ())
 391     {
 392       if (tui_update_breakpoint_info (win, being_deleted, false))
 393         {
 394           tui_update_exec_info (win);
 395         }
 396     }
 397 }
 398
 399
 400 /* Scan the source window and the breakpoints to update the break_mode
 401    information for each line.
 402
 403    Returns true if something changed and the execution window must be
 404    refreshed.  */
 405
 406 bool
 407 tui_update_breakpoint_info (struct tui_source_window_base *win,
 408                             struct breakpoint *being_deleted,
 409                             bool current_only)
 410 {
 411   int i;
 412   bool need_refresh = false;
 413   tui_source_window_base *src = (tui_source_window_base *) win;
 414
 415   for (i = 0; i < win->content.size (); i++)
 416     {
 417       struct breakpoint *bp;
 418       extern struct breakpoint *breakpoint_chain;
 419       struct tui_source_element *line;
 420
 421       line = &win->content[i];
 422       if (current_only && !line->is_exec_point)
 423          continue;
 424
 425       /* Scan each breakpoint to see if the current line has something to
 426          do with it.  Identify enable/disabled breakpoints as well as
 427          those that we already hit.  */
 428       tui_bp_flags mode = 0;
 429       for (bp = breakpoint_chain;
 430            bp != NULL;
 431            bp = bp->next)
 432         {
 433           struct bp_location *loc;
 434
 435           gdb_assert (line->line_or_addr.loa == LOA_LINE
 436                       || line->line_or_addr.loa == LOA_ADDRESS);
 437
 438           if (bp == being_deleted)
 439             continue;
 440
 441           for (loc = bp->loc; loc != NULL; loc = loc->next)
 442             {
 443               if ((win == TUI_SRC_WIN
 444                    && loc->symtab != NULL
 445                    && filename_cmp (src->fullname,
 446                                     symtab_to_fullname (loc->symtab)) == 0
 447                    && line->line_or_addr.loa == LOA_LINE
 448                    && loc->line_number == line->line_or_addr.u.line_no)
 449                   || (win == TUI_DISASM_WIN
 450                       && line->line_or_addr.loa == LOA_ADDRESS
 451                       && loc->address == line->line_or_addr.u.addr))
 452                 {
 453                   if (bp->enable_state == bp_disabled)
 454                     mode |= TUI_BP_DISABLED;
 455                   else
 456                     mode |= TUI_BP_ENABLED;
 457                   if (bp->hit_count)
 458                     mode |= TUI_BP_HIT;
 459                   if (bp->loc->cond)
 460                     mode |= TUI_BP_CONDITIONAL;
 461                   if (bp->type == bp_hardware_breakpoint)
 462                     mode |= TUI_BP_HARDWARE;
 463                 }
 464             }
 465         }
 466       if (line->break_mode != mode)
 467         {
 468           line->break_mode = mode;
 469           need_refresh = true;
 470         }
 471     }
 472   return need_refresh;
 473 }
 474
 475 /* See tui-data.h.  */
 476
 477 tui_exec_info_content *
 478 tui_exec_info_window::maybe_allocate_content (int n_elements)
 479 {
 480   if (m_content == nullptr)
 481     m_content = XNEWVEC (tui_exec_info_content, n_elements);
 482   return m_content;
 483 }
 484
 485
 486 /* Function to initialize the content of the execution info window,
 487    based upon the input window which is either the source or
 488    disassembly window.  */
 489 void
 490 tui_set_exec_info_content (struct tui_source_window_base *win_info)
 491 {
 492   if (win_info->execution_info != NULL)
 493     {
 494       tui_exec_info_content *content
 495         = win_info->execution_info->maybe_allocate_content (win_info->height);
 496
 497       tui_update_breakpoint_info (win_info, nullptr, true);
 498       for (int i = 0; i < win_info->content.size (); i++)
 499         {
 500           tui_exec_info_content &element = content[i];
 501           struct tui_source_element *src_element;
 502           tui_bp_flags mode;
 503
 504           src_element = &win_info->content[i];
 505
 506           memset (element, ' ', sizeof (tui_exec_info_content));
 507           element[TUI_EXECINFO_SIZE - 1] = 0;
 508
 509           /* Now update the exec info content based upon the state
 510              of each line as indicated by the source content.  */
 511           mode = src_element->break_mode;
 512           if (mode & TUI_BP_HIT)
 513             element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 514           else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 515             element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 516
 517           if (mode & TUI_BP_ENABLED)
 518             element[TUI_BP_BREAK_POS] = '+';
 519           else if (mode & TUI_BP_DISABLED)
 520             element[TUI_BP_BREAK_POS] = '-';
 521
 522           if (src_element->is_exec_point)
 523             element[TUI_EXEC_POS] = '>';
 524         }
 525     }
 526 }
 527
 528
 529 void
 530 tui_show_exec_info_content (struct tui_source_window_base *win_info)
 531 {
 532   struct tui_exec_info_window *exec_info = win_info->execution_info;
 533   const tui_exec_info_content *content = exec_info->get_content ();
 534
 535   werase (exec_info->handle);
 536   exec_info->refresh_window ();
 537   for (int cur_line = 1; cur_line <= win_info->content.size (); cur_line++)
 538     mvwaddstr (exec_info->handle,
 539                cur_line,
 540                0,
 541                content[cur_line - 1]);
 542   exec_info->refresh_window ();
 543   exec_info->content_in_use = TRUE;
 544 }
 545
 546
 547 void
 548 tui_erase_exec_info_content (struct tui_source_window_base *win_info)
 549 {
 550   struct tui_gen_win_info *exec_info = win_info->execution_info;
 551
 552   werase (exec_info->handle);
 553   exec_info->refresh_window ();
 554 }
 555
 556 void
 557 tui_clear_exec_info_content (struct tui_source_window_base *win_info)
 558 {
 559   win_info->execution_info->content_in_use = FALSE;
 560   tui_erase_exec_info_content (win_info);
 561 }
 562
 563 /* Function to update the execution info window.  */
 564 void
 565 tui_update_exec_info (struct tui_source_window_base *win_info)
 566 {
 567   tui_set_exec_info_content (win_info);
 568   tui_show_exec_info_content (win_info);
 569 }
 570
 571 void
 572 tui_alloc_source_buffer (struct tui_source_window_base *win_info)
 573 {
 574   int i, line_width, max_lines;
 575
 576   /* The window width/height includes the highlight box.  Determine actual
 577      content dimensions, including string null-terminators.  */
 578   max_lines = win_info->height - 2;
 579   line_width = win_info->width - 2 + 1;
 580
 581   /* Allocate the buffer for the source lines.  */
 582   win_info->content.resize (max_lines);
 583   for (i = 0; i < max_lines; i++)
 584     {
 585       if (win_info->content[i].line == nullptr)
 586         win_info->content[i].line = (char *) xmalloc (line_width);
 587     }
 588 }
 589
 590
 591 /* Answer whether a particular line number or address is displayed
 592    in the current source window.  */
 593 int
 594 tui_line_is_displayed (int line,
 595                        struct tui_source_window_base *win_info,
 596                        int check_threshold)
 597 {
 598   int is_displayed = FALSE;
 599   int i, threshold;
 600
 601   if (check_threshold)
 602     threshold = SCROLL_THRESHOLD;
 603   else
 604     threshold = 0;
 605   i = 0;
 606   while (i < win_info->content.size () - threshold
 607          && !is_displayed)
 608     {
 609       is_displayed
 610         = win_info->content[i].line_or_addr.loa == LOA_LINE
 611           && win_info->content[i].line_or_addr.u.line_no == line;
 612       i++;
 613     }
 614
 615   return is_displayed;
 616 }
 617
 618
 619 /* Answer whether a particular line number or address is displayed
 620    in the current source window.  */
 621 int
 622 tui_addr_is_displayed (CORE_ADDR addr,
 623                        struct tui_source_window_base *win_info,
 624                        int check_threshold)
 625 {
 626   int is_displayed = FALSE;
 627   int i, threshold;
 628
 629   if (check_threshold)
 630     threshold = SCROLL_THRESHOLD;
 631   else
 632     threshold = 0;
 633   i = 0;
 634   while (i < win_info->content.size () - threshold
 635          && !is_displayed)
 636     {
 637       is_displayed
 638         = win_info->content[i].line_or_addr.loa == LOA_ADDRESS
 639           && win_info->content[i].line_or_addr.u.addr == addr;
 640       i++;
 641     }
 642
 643   return is_displayed;
 644 }
 645
 646
 647 /*****************************************
 648 ** STATIC LOCAL FUNCTIONS               **
 649 ******************************************/