gdb/tui/tui-winsource.c

   1 /* TUI display source/assembly window.
   2
   3    Copyright (C) 1998-2021 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 #include "safe-ctype.h"
  32
  33 #include "tui/tui.h"
  34 #include "tui/tui-data.h"
  35 #include "tui/tui-io.h"
  36 #include "tui/tui-stack.h"
  37 #include "tui/tui-win.h"
  38 #include "tui/tui-wingeneral.h"
  39 #include "tui/tui-winsource.h"
  40 #include "tui/tui-source.h"
  41 #include "tui/tui-disasm.h"
  42 #include "gdb_curses.h"
  43
  44 /* Function to display the "main" routine.  */
  45 void
  46 tui_display_main ()
  47 {
  48   auto adapter = tui_source_windows ();
  49   if (adapter.begin () != adapter.end ())
  50     {
  51       struct gdbarch *gdbarch;
  52       CORE_ADDR addr;
  53
  54       tui_get_begin_asm_address (&gdbarch, &addr);
  55       if (addr != (CORE_ADDR) 0)
  56         {
  57           struct symtab *s;
  58
  59           tui_update_source_windows_with_addr (gdbarch, addr);
  60           s = find_pc_line_symtab (addr);
  61           tui_update_locator_fullname (s);
  62         }
  63     }
  64 }
  65
  66 /* See tui-winsource.h.  */
  67
  68 std::string
  69 tui_copy_source_line (const char **ptr, int *length)
  70 {
  71   const char *lineptr = *ptr;
  72
  73   /* Init the line with the line number.  */
  74   std::string result;
  75
  76   int column = 0;
  77   char c;
  78   do
  79     {
  80       int skip_bytes;
  81
  82       c = *lineptr;
  83       if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
  84         {
  85           /* We always have to preserve escapes.  */
  86           result.append (lineptr, lineptr + skip_bytes);
  87           lineptr += skip_bytes;
  88           continue;
  89         }
  90       if (c == '\0')
  91         break;
  92
  93       ++lineptr;
  94       ++column;
  95
  96       auto process_tab = [&] ()
  97         {
  98           int max_tab_len = tui_tab_width;
  99
 100           --column;
 101           for (int j = column % max_tab_len;
 102                j < max_tab_len;
 103                column++, j++)
 104             result.push_back (' ');
 105         };
 106
 107       if (c == '\n' || c == '\r' || c == '\0')
 108         {
 109           /* Nothing.  */
 110         }
 111       else if (c == '\t')
 112         process_tab ();
 113       else if (ISCNTRL (c))
 114         {
 115           result.push_back ('^');
 116           result.push_back (c + 0100);
 117           ++column;
 118         }
 119       else if (c == 0177)
 120         {
 121           result.push_back ('^');
 122           result.push_back ('?');
 123           ++column;
 124         }
 125       else
 126         result.push_back (c);
 127     }
 128   while (c != '\0' && c != '\n' && c != '\r');
 129
 130   if (c == '\r' && *lineptr == '\n')
 131     ++lineptr;
 132   *ptr = lineptr;
 133
 134   if (length != nullptr)
 135     *length = column;
 136
 137   return result;
 138 }
 139
 140 void
 141 tui_source_window_base::style_changed ()
 142 {
 143   if (tui_active && is_visible ())
 144     refill ();
 145 }
 146
 147 /* Function to display source in the source window.  This function
 148    initializes the horizontal scroll to 0.  */
 149 void
 150 tui_source_window_base::update_source_window
 151   (struct gdbarch *gdbarch,
 152    const struct symtab_and_line &sal)
 153 {
 154   m_horizontal_offset = 0;
 155   update_source_window_as_is (gdbarch, sal);
 156 }
 157
 158
 159 /* Function to display source in the source/asm window.  This function
 160    shows the source as specified by the horizontal offset.  */
 161 void
 162 tui_source_window_base::update_source_window_as_is
 163   (struct gdbarch *gdbarch,
 164    const struct symtab_and_line &sal)
 165 {
 166   bool ret = set_contents (gdbarch, sal);
 167
 168   if (!ret)
 169     erase_source_content ();
 170   else
 171     {
 172       update_breakpoint_info (nullptr, false);
 173       show_source_content ();
 174       update_exec_info ();
 175     }
 176 }
 177
 178
 179 /* Function to ensure that the source and/or disassemly windows
 180    reflect the input address.  */
 181 void
 182 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 183 {
 184   struct symtab_and_line sal {};
 185   if (addr != 0)
 186     sal = find_pc_line (addr, 0);
 187
 188   for (struct tui_source_window_base *win_info : tui_source_windows ())
 189     win_info->update_source_window (gdbarch, sal);
 190 }
 191
 192 /* Function to ensure that the source and/or disassembly windows
 193    reflect the symtab and line.  */
 194 void
 195 tui_update_source_windows_with_line (struct symtab_and_line sal)
 196 {
 197   struct gdbarch *gdbarch = nullptr;
 198   if (sal.symtab != nullptr)
 199     {
 200       find_line_pc (sal.symtab, sal.line, &sal.pc);
 201       gdbarch = SYMTAB_OBJFILE (sal.symtab)->arch ();
 202     }
 203
 204   for (struct tui_source_window_base *win_info : tui_source_windows ())
 205     win_info->update_source_window (gdbarch, sal);
 206 }
 207
 208 void
 209 tui_source_window_base::do_erase_source_content (const char *str)
 210 {
 211   int x_pos;
 212   int half_width = (width - 2) / 2;
 213
 214   m_content.clear ();
 215   if (handle != NULL)
 216     {
 217       werase (handle.get ());
 218       check_and_display_highlight_if_needed ();
 219
 220       if (strlen (str) >= half_width)
 221         x_pos = 1;
 222       else
 223         x_pos = half_width - strlen (str);
 224       mvwaddstr (handle.get (),
 225                  (height / 2),
 226                  x_pos,
 227                  (char *) str);
 228
 229       refresh_window ();
 230     }
 231 }
 232
 233
 234 /* Redraw the complete line of a source or disassembly window.  */
 235 void
 236 tui_source_window_base::show_source_line (int lineno)
 237 {
 238   struct tui_source_element *line;
 239
 240   line = &m_content[lineno];
 241   if (line->is_exec_point)
 242     tui_set_reverse_mode (m_pad.get (), true);
 243
 244   wmove (m_pad.get (), lineno, 0);
 245   tui_puts (line->line.c_str (), m_pad.get ());
 246   if (line->is_exec_point)
 247     tui_set_reverse_mode (m_pad.get (), false);
 248 }
 249
 250 /* See tui-winsource.h.  */
 251
 252 void
 253 tui_source_window_base::refresh_window ()
 254 {
 255   tui_win_info::refresh_window ();
 256
 257   int pad_width = std::max (m_max_length, width);
 258   int left_margin = 1 + TUI_EXECINFO_SIZE + extra_margin ();
 259   int view_width = width - left_margin - 1;
 260   int pad_x = std::min (pad_width - view_width, m_horizontal_offset);
 261   /* Ensure that an equal number of scrolls will work if the user
 262      scrolled beyond where we clip.  */
 263   m_horizontal_offset = pad_x;
 264   prefresh (m_pad.get (), 0, pad_x, y + 1, x + left_margin,
 265             y + m_content.size (), x + left_margin + view_width - 1);
 266 }
 267
 268 void
 269 tui_source_window_base::show_source_content ()
 270 {
 271   gdb_assert (!m_content.empty ());
 272
 273   check_and_display_highlight_if_needed ();
 274
 275   int pad_width = std::max (m_max_length, width);
 276   if (m_pad == nullptr || pad_width > getmaxx (m_pad.get ())
 277       || m_content.size () > getmaxy (m_pad.get ()))
 278     m_pad.reset (newpad (m_content.size (), pad_width));
 279
 280   werase (m_pad.get ());
 281   for (int lineno = 0; lineno < m_content.size (); lineno++)
 282     show_source_line (lineno);
 283
 284   refresh_window ();
 285 }
 286
 287 tui_source_window_base::tui_source_window_base ()
 288 {
 289   m_start_line_or_addr.loa = LOA_ADDRESS;
 290   m_start_line_or_addr.u.addr = 0;
 291
 292   gdb::observers::source_styling_changed.attach
 293     (std::bind (&tui_source_window::style_changed, this),
 294      m_observable);
 295 }
 296
 297 tui_source_window_base::~tui_source_window_base ()
 298 {
 299   gdb::observers::source_styling_changed.detach (m_observable);
 300 }
 301
 302 /* See tui-data.h.  */
 303
 304 void
 305 tui_source_window_base::update_tab_width ()
 306 {
 307   werase (handle.get ());
 308   rerender ();
 309 }
 310
 311 void
 312 tui_source_window_base::rerender ()
 313 {
 314   if (!m_content.empty ())
 315     {
 316       struct symtab_and_line cursal
 317         = get_current_source_symtab_and_line ();
 318
 319       if (m_start_line_or_addr.loa == LOA_LINE)
 320         cursal.line = m_start_line_or_addr.u.line_no;
 321       else
 322         cursal.pc = m_start_line_or_addr.u.addr;
 323       update_source_window (m_gdbarch, cursal);
 324     }
 325   else if (deprecated_safe_get_selected_frame () != NULL)
 326     {
 327       struct symtab_and_line cursal
 328         = get_current_source_symtab_and_line ();
 329       struct frame_info *frame = deprecated_safe_get_selected_frame ();
 330       struct gdbarch *gdbarch = get_frame_arch (frame);
 331
 332       struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
 333       if (this != TUI_SRC_WIN)
 334         find_line_pc (s, cursal.line, &cursal.pc);
 335       update_source_window (gdbarch, cursal);
 336     }
 337   else
 338     erase_source_content ();
 339 }
 340
 341 /* See tui-data.h.  */
 342
 343 void
 344 tui_source_window_base::refill ()
 345 {
 346   symtab_and_line sal {};
 347
 348   if (this == TUI_SRC_WIN)
 349     {
 350       sal = get_current_source_symtab_and_line ();
 351       if (sal.symtab == NULL)
 352         {
 353           struct frame_info *fi = deprecated_safe_get_selected_frame ();
 354           if (fi != nullptr)
 355             sal = find_pc_line (get_frame_pc (fi), 0);
 356         }
 357     }
 358
 359   if (sal.pspace == nullptr)
 360     sal.pspace = current_program_space;
 361
 362   if (m_start_line_or_addr.loa == LOA_LINE)
 363     sal.line = m_start_line_or_addr.u.line_no;
 364   else
 365     sal.pc = m_start_line_or_addr.u.addr;
 366
 367   update_source_window_as_is (m_gdbarch, sal);
 368 }
 369
 370 /* Scroll the source forward or backward horizontally.  */
 371
 372 void
 373 tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
 374 {
 375   if (!m_content.empty ())
 376     {
 377       int offset = m_horizontal_offset + num_to_scroll;
 378       if (offset < 0)
 379         offset = 0;
 380       m_horizontal_offset = offset;
 381       refresh_window ();
 382     }
 383 }
 384
 385
 386 /* Set or clear the is_exec_point flag in the line whose line is
 387    line_no.  */
 388
 389 void
 390 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
 391 {
 392   bool changed = false;
 393   int i;
 394
 395   i = 0;
 396   while (i < m_content.size ())
 397     {
 398       bool new_state;
 399       struct tui_line_or_address content_loa =
 400         m_content[i].line_or_addr;
 401
 402       if (content_loa.loa == l.loa
 403           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 404               || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
 405         new_state = true;
 406       else
 407         new_state = false;
 408       if (new_state != m_content[i].is_exec_point)
 409         {
 410           changed = true;
 411           m_content[i].is_exec_point = new_state;
 412         }
 413       i++;
 414     }
 415   if (changed)
 416     refill ();
 417 }
 418
 419 /* See tui-winsource.h.  */
 420
 421 void
 422 tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
 423 {
 424   for (tui_source_window_base *win : tui_source_windows ())
 425     {
 426       if (win->update_breakpoint_info (being_deleted, false))
 427         win->update_exec_info ();
 428     }
 429 }
 430
 431
 432 /* Scan the source window and the breakpoints to update the break_mode
 433    information for each line.
 434
 435    Returns true if something changed and the execution window must be
 436    refreshed.  */
 437
 438 bool
 439 tui_source_window_base::update_breakpoint_info
 440   (struct breakpoint *being_deleted, bool current_only)
 441 {
 442   int i;
 443   bool need_refresh = false;
 444
 445   for (i = 0; i < m_content.size (); i++)
 446     {
 447       struct tui_source_element *line;
 448
 449       line = &m_content[i];
 450       if (current_only && !line->is_exec_point)
 451          continue;
 452
 453       /* Scan each breakpoint to see if the current line has something to
 454          do with it.  Identify enable/disabled breakpoints as well as
 455          those that we already hit.  */
 456       tui_bp_flags mode = 0;
 457       iterate_over_breakpoints ([&] (breakpoint *bp) -> bool
 458         {
 459           struct bp_location *loc;
 460
 461           if (bp == being_deleted)
 462             return false;
 463
 464           for (loc = bp->loc; loc != NULL; loc = loc->next)
 465             {
 466               if (location_matches_p (loc, i))
 467                 {
 468                   if (bp->enable_state == bp_disabled)
 469                     mode |= TUI_BP_DISABLED;
 470                   else
 471                     mode |= TUI_BP_ENABLED;
 472                   if (bp->hit_count)
 473                     mode |= TUI_BP_HIT;
 474                   if (bp->loc->cond)
 475                     mode |= TUI_BP_CONDITIONAL;
 476                   if (bp->type == bp_hardware_breakpoint)
 477                     mode |= TUI_BP_HARDWARE;
 478                 }
 479             }
 480           return false;
 481         });
 482       if (line->break_mode != mode)
 483         {
 484           line->break_mode = mode;
 485           need_refresh = true;
 486         }
 487     }
 488   return need_refresh;
 489 }
 490
 491 /* Function to initialize the content of the execution info window,
 492    based upon the input window which is either the source or
 493    disassembly window.  */
 494 void
 495 tui_source_window_base::update_exec_info ()
 496 {
 497   update_breakpoint_info (nullptr, true);
 498   for (int i = 0; i < m_content.size (); i++)
 499     {
 500       struct tui_source_element *src_element = &m_content[i];
 501       char element[TUI_EXECINFO_SIZE] = "   ";
 502
 503       /* Now update the exec info content based upon the state
 504          of each line as indicated by the source content.  */
 505       tui_bp_flags mode = src_element->break_mode;
 506       if (mode & TUI_BP_HIT)
 507         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 508       else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 509         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 510
 511       if (mode & TUI_BP_ENABLED)
 512         element[TUI_BP_BREAK_POS] = '+';
 513       else if (mode & TUI_BP_DISABLED)
 514         element[TUI_BP_BREAK_POS] = '-';
 515
 516       if (src_element->is_exec_point)
 517         element[TUI_EXEC_POS] = '>';
 518
 519       mvwaddstr (handle.get (), i + 1, 1, element);
 520
 521       show_line_number (i);
 522     }
 523   refresh_window ();
 524 }