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       win_info->update_exec_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   update_exec_info ();
 338 }
 339
 340 /* See tui-data.h.  */
 341
 342 void
 343 tui_source_window_base::update_tab_width ()
 344 {
 345   /* We don't really change the height of any windows, but
 346      calling these 2 functions causes a complete regeneration
 347      and redisplay of the window's contents, which will take
 348      the new tab width into account.  */
 349   make_invisible_and_set_new_height (height);
 350   make_visible_with_new_height ();
 351 }
 352
 353 /* See tui-data.h.  */
 354
 355 void
 356 tui_source_window_base::set_new_height (int height)
 357 {
 358   execution_info->make_visible (false);
 359   execution_info->height = height;
 360   execution_info->origin.y = origin.y;
 361   if (height > 1)
 362     execution_info->viewport_height = height - 1;
 363   else
 364     execution_info->viewport_height = height;
 365   execution_info->viewport_height--;
 366
 367   if (m_has_locator)
 368     {
 369       tui_locator_window *gen_win_info = tui_locator_win_info_ptr ();
 370       gen_win_info->make_visible (false);
 371       gen_win_info->origin.y = origin.y + height;
 372     }
 373 }
 374
 375 /* See tui-data.h.  */
 376
 377 void
 378 tui_source_window_base::do_make_visible_with_new_height ()
 379 {
 380   execution_info->make_visible (true);
 381   if (!content.empty ())
 382     {
 383       struct tui_line_or_address line_or_addr;
 384       struct symtab_and_line cursal
 385         = get_current_source_symtab_and_line ();
 386
 387       line_or_addr = start_line_or_addr;
 388       tui_update_source_window (this, gdbarch,
 389                                 cursal.symtab, line_or_addr, TRUE);
 390     }
 391   else if (deprecated_safe_get_selected_frame () != NULL)
 392     {
 393       struct tui_line_or_address line;
 394       struct symtab_and_line cursal
 395         = get_current_source_symtab_and_line ();
 396       struct frame_info *frame = deprecated_safe_get_selected_frame ();
 397       struct gdbarch *gdbarch = get_frame_arch (frame);
 398
 399       struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
 400       if (type == SRC_WIN)
 401         {
 402           line.loa = LOA_LINE;
 403           line.u.line_no = cursal.line;
 404         }
 405       else
 406         {
 407           line.loa = LOA_ADDRESS;
 408           find_line_pc (s, cursal.line, &line.u.addr);
 409         }
 410       tui_update_source_window (this, gdbarch, s, line, TRUE);
 411     }
 412   if (m_has_locator)
 413     {
 414       tui_locator_win_info_ptr ()->make_visible (true);
 415       tui_show_locator_content ();
 416     }
 417 }
 418
 419 /* See tui-data.h.  */
 420
 421 void
 422 tui_source_window_base::make_visible (bool visible)
 423 {
 424   execution_info->make_visible (visible);
 425   tui_win_info::make_visible (visible);
 426 }
 427
 428 /* See tui-data.h.  */
 429
 430 void
 431 tui_source_window_base::refresh_window ()
 432 {
 433   execution_info->refresh_window ();
 434   tui_win_info::refresh_window ();
 435 }
 436
 437 /* See tui-data.h.  */
 438
 439 void
 440 tui_source_window_base::refill ()
 441 {
 442   symtab *s = nullptr;
 443
 444   if (type == SRC_WIN)
 445     {
 446       symtab_and_line cursal = get_current_source_symtab_and_line ();
 447       s = (cursal.symtab == NULL
 448            ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
 449            : cursal.symtab);
 450     }
 451
 452   tui_update_source_window_as_is (this, gdbarch, s,
 453                                   content[0].line_or_addr,
 454                                   FALSE);
 455 }
 456
 457 /* Scroll the source forward or backward horizontally.  */
 458
 459 void
 460 tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
 461 {
 462   if (!content.empty ())
 463     {
 464       int offset = horizontal_offset + num_to_scroll;
 465       if (offset < 0)
 466         offset = 0;
 467       horizontal_offset = offset;
 468       refill ();
 469     }
 470 }
 471
 472
 473 /* Set or clear the is_exec_point flag in the line whose line is
 474    line_no.  */
 475
 476 void
 477 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
 478 {
 479   bool changed = false;
 480   int i;
 481
 482   i = 0;
 483   while (i < content.size ())
 484     {
 485       bool new_state;
 486       struct tui_line_or_address content_loa =
 487         content[i].line_or_addr;
 488
 489       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 490       gdb_assert (content_loa.loa == LOA_LINE
 491                   || content_loa.loa == LOA_ADDRESS);
 492       if (content_loa.loa == l.loa
 493           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 494               || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
 495         new_state = true;
 496       else
 497         new_state = false;
 498       if (new_state != content[i].is_exec_point)
 499         {
 500           changed = true;
 501           content[i].is_exec_point = new_state;
 502           tui_show_source_line (this, i + 1);
 503         }
 504       i++;
 505     }
 506   if (changed)
 507     refill ();
 508 }
 509
 510 /* See tui-winsource.h.  */
 511
 512 void
 513 tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
 514 {
 515   for (tui_source_window_base *win : tui_source_windows ())
 516     {
 517       if (tui_update_breakpoint_info (win, being_deleted, false))
 518         {
 519           win->update_exec_info ();
 520         }
 521     }
 522 }
 523
 524
 525 /* Scan the source window and the breakpoints to update the break_mode
 526    information for each line.
 527
 528    Returns true if something changed and the execution window must be
 529    refreshed.  */
 530
 531 bool
 532 tui_update_breakpoint_info (struct tui_source_window_base *win,
 533                             struct breakpoint *being_deleted,
 534                             bool current_only)
 535 {
 536   int i;
 537   bool need_refresh = false;
 538
 539   for (i = 0; i < win->content.size (); i++)
 540     {
 541       struct breakpoint *bp;
 542       extern struct breakpoint *breakpoint_chain;
 543       struct tui_source_element *line;
 544
 545       line = &win->content[i];
 546       if (current_only && !line->is_exec_point)
 547          continue;
 548
 549       /* Scan each breakpoint to see if the current line has something to
 550          do with it.  Identify enable/disabled breakpoints as well as
 551          those that we already hit.  */
 552       tui_bp_flags mode = 0;
 553       for (bp = breakpoint_chain;
 554            bp != NULL;
 555            bp = bp->next)
 556         {
 557           struct bp_location *loc;
 558
 559           gdb_assert (line->line_or_addr.loa == LOA_LINE
 560                       || line->line_or_addr.loa == LOA_ADDRESS);
 561
 562           if (bp == being_deleted)
 563             continue;
 564
 565           for (loc = bp->loc; loc != NULL; loc = loc->next)
 566             {
 567               if (win->location_matches_p (loc, i))
 568                 {
 569                   if (bp->enable_state == bp_disabled)
 570                     mode |= TUI_BP_DISABLED;
 571                   else
 572                     mode |= TUI_BP_ENABLED;
 573                   if (bp->hit_count)
 574                     mode |= TUI_BP_HIT;
 575                   if (bp->loc->cond)
 576                     mode |= TUI_BP_CONDITIONAL;
 577                   if (bp->type == bp_hardware_breakpoint)
 578                     mode |= TUI_BP_HARDWARE;
 579                 }
 580             }
 581         }
 582       if (line->break_mode != mode)
 583         {
 584           line->break_mode = mode;
 585           need_refresh = true;
 586         }
 587     }
 588   return need_refresh;
 589 }
 590
 591 /* See tui-data.h.  */
 592
 593 tui_exec_info_content *
 594 tui_exec_info_window::maybe_allocate_content (int n_elements)
 595 {
 596   if (m_content == nullptr)
 597     m_content = XNEWVEC (tui_exec_info_content, n_elements);
 598   return m_content;
 599 }
 600
 601
 602 /* Function to initialize the content of the execution info window,
 603    based upon the input window which is either the source or
 604    disassembly window.  */
 605 void
 606 tui_source_window_base::set_exec_info_content ()
 607 {
 608   tui_exec_info_content *exec_content
 609     = execution_info->maybe_allocate_content (height);
 610
 611   tui_update_breakpoint_info (this, nullptr, true);
 612   for (int i = 0; i < content.size (); i++)
 613     {
 614       tui_exec_info_content &element = exec_content[i];
 615       struct tui_source_element *src_element;
 616       tui_bp_flags mode;
 617
 618       src_element = &content[i];
 619
 620       memset (element, ' ', sizeof (tui_exec_info_content));
 621       element[TUI_EXECINFO_SIZE - 1] = 0;
 622
 623       /* Now update the exec info content based upon the state
 624          of each line as indicated by the source content.  */
 625       mode = src_element->break_mode;
 626       if (mode & TUI_BP_HIT)
 627         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 628       else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 629         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 630
 631       if (mode & TUI_BP_ENABLED)
 632         element[TUI_BP_BREAK_POS] = '+';
 633       else if (mode & TUI_BP_DISABLED)
 634         element[TUI_BP_BREAK_POS] = '-';
 635
 636       if (src_element->is_exec_point)
 637         element[TUI_EXEC_POS] = '>';
 638     }
 639 }
 640
 641
 642 void
 643 tui_source_window_base::show_exec_info_content ()
 644 {
 645   struct tui_exec_info_window *exec_info = execution_info;
 646   const tui_exec_info_content *exec_content = exec_info->get_content ();
 647
 648   werase (exec_info->handle);
 649   for (int cur_line = 1; cur_line <= content.size (); cur_line++)
 650     mvwaddstr (exec_info->handle,
 651                cur_line,
 652                0,
 653                exec_content[cur_line - 1]);
 654   exec_info->refresh_window ();
 655 }
 656
 657
 658 void
 659 tui_clear_exec_info_content (struct tui_source_window_base *win_info)
 660 {
 661   struct tui_gen_win_info *exec_info = win_info->execution_info;
 662
 663   werase (exec_info->handle);
 664   exec_info->refresh_window ();
 665 }
 666
 667 /* Function to update the execution info window.  */
 668 void
 669 tui_source_window_base::update_exec_info ()
 670 {
 671   set_exec_info_content ();
 672   show_exec_info_content ();
 673 }
 674
 675 void
 676 tui_alloc_source_buffer (struct tui_source_window_base *win_info)
 677 {
 678   int i, line_width, max_lines;
 679
 680   /* The window width/height includes the highlight box.  Determine actual
 681      content dimensions, including string null-terminators.  */
 682   max_lines = win_info->height - 2;
 683   line_width = win_info->width - 2 + 1;
 684
 685   /* Allocate the buffer for the source lines.  */
 686   win_info->content.resize (max_lines);
 687   for (i = 0; i < max_lines; i++)
 688     {
 689       if (win_info->content[i].line == nullptr)
 690         win_info->content[i].line = (char *) xmalloc (line_width);
 691     }
 692 }
 693
 694
 695 /* Answer whether a particular line number or address is displayed
 696    in the current source window.  */
 697 int
 698 tui_line_is_displayed (int line,
 699                        struct tui_source_window_base *win_info,
 700                        int check_threshold)
 701 {
 702   int is_displayed = FALSE;
 703   int i, threshold;
 704
 705   if (check_threshold)
 706     threshold = SCROLL_THRESHOLD;
 707   else
 708     threshold = 0;
 709   i = 0;
 710   while (i < win_info->content.size () - threshold
 711          && !is_displayed)
 712     {
 713       is_displayed
 714         = win_info->content[i].line_or_addr.loa == LOA_LINE
 715           && win_info->content[i].line_or_addr.u.line_no == line;
 716       i++;
 717     }
 718
 719   return is_displayed;
 720 }
 721
 722
 723 /* Answer whether a particular line number or address is displayed
 724    in the current source window.  */
 725 int
 726 tui_addr_is_displayed (CORE_ADDR addr,
 727                        struct tui_source_window_base *win_info,
 728                        int check_threshold)
 729 {
 730   int is_displayed = FALSE;
 731   int i, threshold;
 732
 733   if (check_threshold)
 734     threshold = SCROLL_THRESHOLD;
 735   else
 736     threshold = 0;
 737   i = 0;
 738   while (i < win_info->content.size () - threshold
 739          && !is_displayed)
 740     {
 741       is_displayed
 742         = win_info->content[i].line_or_addr.loa == LOA_ADDRESS
 743           && win_info->content[i].line_or_addr.u.addr == addr;
 744       i++;
 745     }
 746
 747   return is_displayed;
 748 }