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