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
  82
  83 /* Function to display source in the source/asm window.  This function
  84    shows the source as specified by the horizontal offset.  */
  85 void
  86 tui_update_source_window_as_is (struct tui_source_window_base *win_info,
  87                                 struct gdbarch *gdbarch,
  88                                 struct symtab *s,
  89                                 struct tui_line_or_address line_or_addr,
  90                                 int noerror)
  91 {
  92   enum tui_status ret;
  93
  94   if (win_info->type == SRC_WIN)
  95     ret = tui_set_source_content (win_info, s, line_or_addr.u.line_no,
  96                                   noerror);
  97   else
  98     ret = tui_set_disassem_content (win_info, gdbarch, line_or_addr.u.addr);
  99
 100   if (ret == TUI_FAILURE)
 101     {
 102       tui_clear_source_content (win_info);
 103       tui_clear_exec_info_content (win_info);
 104     }
 105   else
 106     {
 107       tui_update_breakpoint_info (win_info, nullptr, false);
 108       win_info->show_source_content ();
 109       tui_update_exec_info (win_info);
 110       if (win_info->type == SRC_WIN)
 111         {
 112           symtab_and_line sal;
 113
 114           sal.line = line_or_addr.u.line_no +
 115             (win_info->content.size () - 2);
 116           sal.symtab = s;
 117           sal.pspace = SYMTAB_PSPACE (s);
 118           set_current_source_symtab_and_line (sal);
 119           /* If the focus was in the asm win, put it in the src win if
 120              we don't have a split layout.  */
 121           if (tui_win_with_focus () == TUI_DISASM_WIN
 122               && tui_current_layout () != SRC_DISASSEM_COMMAND)
 123             tui_set_win_focus_to (win_info);
 124         }
 125     }
 126 }
 127
 128
 129 /* Function to ensure that the source and/or disassemly windows
 130    reflect the input address.  */
 131 void
 132 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 133 {
 134   if (addr != 0)
 135     {
 136       struct symtab_and_line sal;
 137       struct tui_line_or_address l;
 138
 139       switch (tui_current_layout ())
 140         {
 141         case DISASSEM_COMMAND:
 142         case DISASSEM_DATA_COMMAND:
 143           tui_show_disassem (gdbarch, addr);
 144           break;
 145         case SRC_DISASSEM_COMMAND:
 146           tui_show_disassem_and_update_source (gdbarch, addr);
 147           break;
 148         default:
 149           sal = find_pc_line (addr, 0);
 150           l.loa = LOA_LINE;
 151           l.u.line_no = sal.line;
 152           tui_show_symtab_source (TUI_SRC_WIN, gdbarch, sal.symtab, l, FALSE);
 153           break;
 154         }
 155     }
 156   else
 157     {
 158       for (struct tui_source_window_base *win_info : tui_source_windows ())
 159         {
 160           tui_clear_source_content (win_info);
 161           tui_clear_exec_info_content (win_info);
 162         }
 163     }
 164 }
 165
 166 /* Function to ensure that the source and/or disassemly windows
 167    reflect the input address.  */
 168 void
 169 tui_update_source_windows_with_line (struct symtab *s, int line)
 170 {
 171   struct gdbarch *gdbarch;
 172   CORE_ADDR pc;
 173   struct tui_line_or_address l;
 174
 175   if (!s)
 176     return;
 177
 178   gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
 179
 180   switch (tui_current_layout ())
 181     {
 182     case DISASSEM_COMMAND:
 183     case DISASSEM_DATA_COMMAND:
 184       find_line_pc (s, line, &pc);
 185       tui_update_source_windows_with_addr (gdbarch, pc);
 186       break;
 187     default:
 188       l.loa = LOA_LINE;
 189       l.u.line_no = line;
 190       tui_show_symtab_source (TUI_SRC_WIN, gdbarch, s, l, FALSE);
 191       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 192         {
 193           find_line_pc (s, line, &pc);
 194           tui_show_disassem (gdbarch, pc);
 195         }
 196       break;
 197     }
 198 }
 199
 200 void
 201 tui_clear_source_content (struct tui_source_window_base *win_info)
 202 {
 203   if (win_info != NULL)
 204     {
 205       int i;
 206
 207       tui_erase_source_content (win_info);
 208       for (i = 0; i < win_info->content.size (); i++)
 209         {
 210           struct tui_source_element *element = &win_info->content[i];
 211
 212           element->break_mode = 0;
 213           element->is_exec_point = false;
 214         }
 215     }
 216 }
 217
 218
 219 void
 220 tui_erase_source_content (struct tui_source_window_base *win_info)
 221 {
 222   int x_pos;
 223   int half_width = (win_info->width - 2) / 2;
 224
 225   if (win_info->handle != NULL)
 226     {
 227       werase (win_info->handle);
 228       win_info->check_and_display_highlight_if_needed ();
 229
 230       const char *no_src_str;
 231
 232       if (win_info->type == SRC_WIN)
 233         no_src_str = NO_SRC_STRING;
 234       else
 235         no_src_str = NO_DISASSEM_STRING;
 236       if (strlen (no_src_str) >= half_width)
 237         x_pos = 1;
 238       else
 239         x_pos = half_width - strlen (no_src_str);
 240       mvwaddstr (win_info->handle,
 241                  (win_info->height / 2),
 242                  x_pos,
 243                  (char *) no_src_str);
 244
 245       win_info->content.clear ();
 246       win_info->refresh_window ();
 247     }
 248 }
 249
 250
 251 /* Redraw the complete line of a source or disassembly window.  */
 252 static void
 253 tui_show_source_line (struct tui_source_window_base *win_info, int lineno)
 254 {
 255   struct tui_source_element *line;
 256   int x;
 257
 258   line = &win_info->content[lineno - 1];
 259   if (line->is_exec_point)
 260     tui_set_reverse_mode (win_info->handle, true);
 261
 262   wmove (win_info->handle, lineno, 1);
 263   tui_puts (line->line,
 264             win_info->handle);
 265   if (line->is_exec_point)
 266     tui_set_reverse_mode (win_info->handle, false);
 267
 268   /* Clear to end of line but stop before the border.  */
 269   x = getcurx (win_info->handle);
 270   while (x + 1 < win_info->width)
 271     {
 272       waddch (win_info->handle, ' ');
 273       x = getcurx (win_info->handle);
 274     }
 275 }
 276
 277 void
 278 tui_source_window_base::show_source_content ()
 279 {
 280   if (!content.empty ())
 281     {
 282       int lineno;
 283
 284       for (lineno = 1; lineno <= content.size (); lineno++)
 285         tui_show_source_line (this, lineno);
 286     }
 287   else
 288     tui_erase_source_content (this);
 289
 290   check_and_display_highlight_if_needed ();
 291   refresh_window ();
 292 }
 293
 294 /* See tui-data.h.  */
 295
 296 void
 297 tui_source_window_base::clear_detail ()
 298 {
 299   gdbarch = NULL;
 300   start_line_or_addr.loa = LOA_ADDRESS;
 301   start_line_or_addr.u.addr = 0;
 302   horizontal_offset = 0;
 303 }
 304
 305 tui_source_window_base::tui_source_window_base (enum tui_win_type type)
 306   : tui_win_info (type),
 307     execution_info (new tui_exec_info_window ())
 308 {
 309   gdb_assert (type == SRC_WIN || type == DISASSEM_WIN);
 310   start_line_or_addr.loa = LOA_ADDRESS;
 311   start_line_or_addr.u.addr = 0;
 312 }
 313
 314
 315 tui_source_window_base::~tui_source_window_base ()
 316 {
 317   xfree (fullname);
 318   delete execution_info;
 319 }
 320
 321 void
 322 tui_source_window_base::reset (int height, int width,
 323                                int origin_x, int origin_y)
 324 {
 325   tui_gen_win_info::reset (height, width - 3,
 326                            origin_x + 3, origin_y);
 327   execution_info->reset (height, 3, origin_x, origin_y);
 328 }
 329
 330 /* See tui-data.h.  */
 331
 332 void
 333 tui_source_window_base::refresh_all ()
 334 {
 335   show_source_content ();
 336   check_and_display_highlight_if_needed ();
 337   tui_erase_exec_info_content (this);
 338   tui_update_exec_info (this);
 339 }
 340
 341 /* See tui-data.h.  */
 342
 343 void
 344 tui_source_window_base::update_tab_width ()
 345 {
 346   /* We don't really change the height of any windows, but
 347      calling these 2 functions causes a complete regeneration
 348      and redisplay of the window's contents, which will take
 349      the new tab width into account.  */
 350   make_invisible_and_set_new_height (height);
 351   make_visible_with_new_height ();
 352 }
 353
 354 /* See tui-data.h.  */
 355
 356 void
 357 tui_source_window_base::set_new_height (int height)
 358 {
 359   execution_info->make_visible (false);
 360   execution_info->height = height;
 361   execution_info->origin.y = origin.y;
 362   if (height > 1)
 363     execution_info->viewport_height = height - 1;
 364   else
 365     execution_info->viewport_height = height;
 366   execution_info->viewport_height--;
 367
 368   if (m_has_locator)
 369     {
 370       tui_locator_window *gen_win_info = tui_locator_win_info_ptr ();
 371       gen_win_info->make_visible (false);
 372       gen_win_info->origin.y = origin.y + height;
 373     }
 374 }
 375
 376 /* See tui-data.h.  */
 377
 378 void
 379 tui_source_window_base::do_make_visible_with_new_height ()
 380 {
 381   execution_info->make_visible (true);
 382   if (!content.empty ())
 383     {
 384       struct tui_line_or_address line_or_addr;
 385       struct symtab_and_line cursal
 386         = get_current_source_symtab_and_line ();
 387
 388       line_or_addr = start_line_or_addr;
 389       tui_update_source_window (this, gdbarch,
 390                                 cursal.symtab, line_or_addr, TRUE);
 391     }
 392   else if (deprecated_safe_get_selected_frame () != NULL)
 393     {
 394       struct tui_line_or_address line;
 395       struct symtab_and_line cursal
 396         = get_current_source_symtab_and_line ();
 397       struct frame_info *frame = deprecated_safe_get_selected_frame ();
 398       struct gdbarch *gdbarch = get_frame_arch (frame);
 399
 400       struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
 401       if (type == SRC_WIN)
 402         {
 403           line.loa = LOA_LINE;
 404           line.u.line_no = cursal.line;
 405         }
 406       else
 407         {
 408           line.loa = LOA_ADDRESS;
 409           find_line_pc (s, cursal.line, &line.u.addr);
 410         }
 411       tui_update_source_window (this, gdbarch, s, line, TRUE);
 412     }
 413   if (m_has_locator)
 414     {
 415       tui_locator_win_info_ptr ()->make_visible (true);
 416       tui_show_locator_content ();
 417     }
 418 }
 419
 420 /* See tui-data.h.  */
 421
 422 void
 423 tui_source_window_base::make_visible (bool visible)
 424 {
 425   execution_info->make_visible (visible);
 426   tui_win_info::make_visible (visible);
 427 }
 428
 429 /* See tui-data.h.  */
 430
 431 void
 432 tui_source_window_base::refresh_window ()
 433 {
 434   execution_info->refresh_window ();
 435   tui_win_info::refresh_window ();
 436 }
 437
 438 /* See tui-data.h.  */
 439
 440 void
 441 tui_source_window_base::refill ()
 442 {
 443   symtab *s = nullptr;
 444
 445   if (type == SRC_WIN)
 446     {
 447       symtab_and_line cursal = get_current_source_symtab_and_line ();
 448       s = (cursal.symtab == NULL
 449            ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
 450            : cursal.symtab);
 451     }
 452
 453   tui_update_source_window_as_is (this, gdbarch, s,
 454                                   content[0].line_or_addr,
 455                                   FALSE);
 456 }
 457
 458 /* Scroll the source forward or backward horizontally.  */
 459
 460 void
 461 tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
 462 {
 463   if (!content.empty ())
 464     {
 465       int offset = horizontal_offset + num_to_scroll;
 466       if (offset < 0)
 467         offset = 0;
 468       horizontal_offset = offset;
 469       refill ();
 470     }
 471 }
 472
 473
 474 /* Set or clear the is_exec_point flag in the line whose line is
 475    line_no.  */
 476
 477 void
 478 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
 479 {
 480   bool changed = false;
 481   int i;
 482
 483   i = 0;
 484   while (i < content.size ())
 485     {
 486       bool new_state;
 487       struct tui_line_or_address content_loa =
 488         content[i].line_or_addr;
 489
 490       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 491       gdb_assert (content_loa.loa == LOA_LINE
 492                   || content_loa.loa == LOA_ADDRESS);
 493       if (content_loa.loa == l.loa
 494           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 495               || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
 496         new_state = true;
 497       else
 498         new_state = false;
 499       if (new_state != content[i].is_exec_point)
 500         {
 501           changed = true;
 502           content[i].is_exec_point = new_state;
 503           tui_show_source_line (this, i + 1);
 504         }
 505       i++;
 506     }
 507   if (changed)
 508     refill ();
 509 }
 510
 511 /* See tui-winsource.h.  */
 512
 513 void
 514 tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
 515 {
 516   for (tui_source_window_base *win : tui_source_windows ())
 517     {
 518       if (tui_update_breakpoint_info (win, being_deleted, false))
 519         {
 520           tui_update_exec_info (win);
 521         }
 522     }
 523 }
 524
 525
 526 /* Scan the source window and the breakpoints to update the break_mode
 527    information for each line.
 528
 529    Returns true if something changed and the execution window must be
 530    refreshed.  */
 531
 532 bool
 533 tui_update_breakpoint_info (struct tui_source_window_base *win,
 534                             struct breakpoint *being_deleted,
 535                             bool current_only)
 536 {
 537   int i;
 538   bool need_refresh = false;
 539
 540   for (i = 0; i < win->content.size (); i++)
 541     {
 542       struct breakpoint *bp;
 543       extern struct breakpoint *breakpoint_chain;
 544       struct tui_source_element *line;
 545
 546       line = &win->content[i];
 547       if (current_only && !line->is_exec_point)
 548          continue;
 549
 550       /* Scan each breakpoint to see if the current line has something to
 551          do with it.  Identify enable/disabled breakpoints as well as
 552          those that we already hit.  */
 553       tui_bp_flags mode = 0;
 554       for (bp = breakpoint_chain;
 555            bp != NULL;
 556            bp = bp->next)
 557         {
 558           struct bp_location *loc;
 559
 560           gdb_assert (line->line_or_addr.loa == LOA_LINE
 561                       || line->line_or_addr.loa == LOA_ADDRESS);
 562
 563           if (bp == being_deleted)
 564             continue;
 565
 566           for (loc = bp->loc; loc != NULL; loc = loc->next)
 567             {
 568               if (win->location_matches_p (loc, i))
 569                 {
 570                   if (bp->enable_state == bp_disabled)
 571                     mode |= TUI_BP_DISABLED;
 572                   else
 573                     mode |= TUI_BP_ENABLED;
 574                   if (bp->hit_count)
 575                     mode |= TUI_BP_HIT;
 576                   if (bp->loc->cond)
 577                     mode |= TUI_BP_CONDITIONAL;
 578                   if (bp->type == bp_hardware_breakpoint)
 579                     mode |= TUI_BP_HARDWARE;
 580                 }
 581             }
 582         }
 583       if (line->break_mode != mode)
 584         {
 585           line->break_mode = mode;
 586           need_refresh = true;
 587         }
 588     }
 589   return need_refresh;
 590 }
 591
 592 /* See tui-data.h.  */
 593
 594 tui_exec_info_content *
 595 tui_exec_info_window::maybe_allocate_content (int n_elements)
 596 {
 597   if (m_content == nullptr)
 598     m_content = XNEWVEC (tui_exec_info_content, n_elements);
 599   return m_content;
 600 }
 601
 602
 603 /* Function to initialize the content of the execution info window,
 604    based upon the input window which is either the source or
 605    disassembly window.  */
 606 void
 607 tui_set_exec_info_content (struct tui_source_window_base *win_info)
 608 {
 609   tui_exec_info_content *content
 610     = win_info->execution_info->maybe_allocate_content (win_info->height);
 611
 612   tui_update_breakpoint_info (win_info, nullptr, true);
 613   for (int i = 0; i < win_info->content.size (); i++)
 614     {
 615       tui_exec_info_content &element = content[i];
 616       struct tui_source_element *src_element;
 617       tui_bp_flags mode;
 618
 619       src_element = &win_info->content[i];
 620
 621       memset (element, ' ', sizeof (tui_exec_info_content));
 622       element[TUI_EXECINFO_SIZE - 1] = 0;
 623
 624       /* Now update the exec info content based upon the state
 625          of each line as indicated by the source content.  */
 626       mode = src_element->break_mode;
 627       if (mode & TUI_BP_HIT)
 628         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 629       else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 630         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 631
 632       if (mode & TUI_BP_ENABLED)
 633         element[TUI_BP_BREAK_POS] = '+';
 634       else if (mode & TUI_BP_DISABLED)
 635         element[TUI_BP_BREAK_POS] = '-';
 636
 637       if (src_element->is_exec_point)
 638         element[TUI_EXEC_POS] = '>';
 639     }
 640 }
 641
 642
 643 void
 644 tui_show_exec_info_content (struct tui_source_window_base *win_info)
 645 {
 646   struct tui_exec_info_window *exec_info = win_info->execution_info;
 647   const tui_exec_info_content *content = exec_info->get_content ();
 648
 649   werase (exec_info->handle);
 650   for (int cur_line = 1; cur_line <= win_info->content.size (); cur_line++)
 651     mvwaddstr (exec_info->handle,
 652                cur_line,
 653                0,
 654                content[cur_line - 1]);
 655   exec_info->refresh_window ();
 656 }
 657
 658
 659 void
 660 tui_erase_exec_info_content (struct tui_source_window_base *win_info)
 661 {
 662   struct tui_gen_win_info *exec_info = win_info->execution_info;
 663
 664   werase (exec_info->handle);
 665   exec_info->refresh_window ();
 666 }
 667
 668 void
 669 tui_clear_exec_info_content (struct tui_source_window_base *win_info)
 670 {
 671   tui_erase_exec_info_content (win_info);
 672 }
 673
 674 /* Function to update the execution info window.  */
 675 void
 676 tui_update_exec_info (struct tui_source_window_base *win_info)
 677 {
 678   tui_set_exec_info_content (win_info);
 679   tui_show_exec_info_content (win_info);
 680 }
 681
 682 void
 683 tui_alloc_source_buffer (struct tui_source_window_base *win_info)
 684 {
 685   int i, line_width, max_lines;
 686
 687   /* The window width/height includes the highlight box.  Determine actual
 688      content dimensions, including string null-terminators.  */
 689   max_lines = win_info->height - 2;
 690   line_width = win_info->width - 2 + 1;
 691
 692   /* Allocate the buffer for the source lines.  */
 693   win_info->content.resize (max_lines);
 694   for (i = 0; i < max_lines; i++)
 695     {
 696       if (win_info->content[i].line == nullptr)
 697         win_info->content[i].line = (char *) xmalloc (line_width);
 698     }
 699 }
 700
 701
 702 /* Answer whether a particular line number or address is displayed
 703    in the current source window.  */
 704 int
 705 tui_line_is_displayed (int line,
 706                        struct tui_source_window_base *win_info,
 707                        int check_threshold)
 708 {
 709   int is_displayed = FALSE;
 710   int i, threshold;
 711
 712   if (check_threshold)
 713     threshold = SCROLL_THRESHOLD;
 714   else
 715     threshold = 0;
 716   i = 0;
 717   while (i < win_info->content.size () - threshold
 718          && !is_displayed)
 719     {
 720       is_displayed
 721         = win_info->content[i].line_or_addr.loa == LOA_LINE
 722           && win_info->content[i].line_or_addr.u.line_no == line;
 723       i++;
 724     }
 725
 726   return is_displayed;
 727 }
 728
 729
 730 /* Answer whether a particular line number or address is displayed
 731    in the current source window.  */
 732 int
 733 tui_addr_is_displayed (CORE_ADDR addr,
 734                        struct tui_source_window_base *win_info,
 735                        int check_threshold)
 736 {
 737   int is_displayed = FALSE;
 738   int i, threshold;
 739
 740   if (check_threshold)
 741     threshold = SCROLL_THRESHOLD;
 742   else
 743     threshold = 0;
 744   i = 0;
 745   while (i < win_info->content.size () - threshold
 746          && !is_displayed)
 747     {
 748       is_displayed
 749         = win_info->content[i].line_or_addr.loa == LOA_ADDRESS
 750           && win_info->content[i].line_or_addr.u.addr == addr;
 751       i++;
 752     }
 753
 754   return is_displayed;
 755 }