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   auto adapter = tui_source_windows ();
  48   if (adapter.begin () != adapter.end ())
  49     {
  50       struct gdbarch *gdbarch;
  51       CORE_ADDR addr;
  52
  53       tui_get_begin_asm_address (&gdbarch, &addr);
  54       if (addr != (CORE_ADDR) 0)
  55         {
  56           struct symtab *s;
  57
  58           tui_update_source_windows_with_addr (gdbarch, addr);
  59           s = find_pc_line_symtab (addr);
  60           if (s != NULL)
  61              tui_update_locator_fullname (symtab_to_fullname (s));
  62           else
  63              tui_update_locator_fullname ("??");
  64         }
  65     }
  66 }
  67
  68 /* See tui-winsource.h.  */
  69
  70 std::string
  71 tui_copy_source_line (const char **ptr, int line_no, int first_col,
  72                       int line_width, int ndigits)
  73 {
  74   const char *lineptr = *ptr;
  75
  76   /* Init the line with the line number.  */
  77   std::string result;
  78
  79   if (line_no > 0)
  80     {
  81       if (ndigits > 0)
  82         result = string_printf ("%*d ", ndigits, line_no);
  83       else
  84         {
  85           result = string_printf ("%-6d", line_no);
  86           int len = result.size ();
  87           len = len - ((len / tui_tab_width) * tui_tab_width);
  88           result.append (len, ' ');
  89         }
  90     }
  91
  92   int column = 0;
  93   char c;
  94   do
  95     {
  96       int skip_bytes;
  97
  98       c = *lineptr;
  99       if (c == '\033' && skip_ansi_escape (lineptr, &skip_bytes))
 100         {
 101           /* We always have to preserve escapes.  */
 102           result.append (lineptr, lineptr + skip_bytes);
 103           lineptr += skip_bytes;
 104           continue;
 105         }
 106       if (c == '\0')
 107         break;
 108
 109       ++lineptr;
 110       ++column;
 111
 112       auto process_tab = [&] ()
 113         {
 114           int max_tab_len = tui_tab_width;
 115
 116           --column;
 117           for (int j = column % max_tab_len;
 118                j < max_tab_len && column < first_col + line_width;
 119                column++, j++)
 120             if (column >= first_col)
 121               result.push_back (' ');
 122         };
 123
 124       /* We have to process all the text in order to pick up all the
 125          escapes.  */
 126       if (column <= first_col || column > first_col + line_width)
 127         {
 128           if (c == '\t')
 129             process_tab ();
 130           continue;
 131         }
 132
 133       if (c == '\n' || c == '\r' || c == '\0')
 134         {
 135           /* Nothing.  */
 136         }
 137       else if (c < 040 && c != '\t')
 138         {
 139           result.push_back ('^');
 140           result.push_back (c + 0100);
 141         }
 142       else if (c == 0177)
 143         {
 144           result.push_back ('^');
 145           result.push_back ('?');
 146         }
 147       else if (c == '\t')
 148         process_tab ();
 149       else
 150         result.push_back (c);
 151     }
 152   while (c != '\0' && c != '\n' && c != '\r');
 153
 154   if (c == '\r' && *lineptr == '\n')
 155     ++lineptr;
 156   *ptr = lineptr;
 157
 158   return result;
 159 }
 160
 161 void
 162 tui_source_window_base::style_changed ()
 163 {
 164   if (tui_active && is_visible ())
 165     refill ();
 166 }
 167
 168 /* Function to display source in the source window.  This function
 169    initializes the horizontal scroll to 0.  */
 170 void
 171 tui_source_window_base::update_source_window
 172   (struct gdbarch *gdbarch,
 173    struct symtab *s,
 174    struct tui_line_or_address line_or_addr)
 175 {
 176   horizontal_offset = 0;
 177   update_source_window_as_is (gdbarch, s, line_or_addr);
 178 }
 179
 180
 181 /* Function to display source in the source/asm window.  This function
 182    shows the source as specified by the horizontal offset.  */
 183 void
 184 tui_source_window_base::update_source_window_as_is
 185   (struct gdbarch *gdbarch,
 186    struct symtab *s,
 187    struct tui_line_or_address line_or_addr)
 188 {
 189   enum tui_status ret
 190     = set_contents (gdbarch, s, line_or_addr);
 191
 192   if (ret == TUI_FAILURE)
 193     erase_source_content ();
 194   else
 195     {
 196       update_breakpoint_info (nullptr, false);
 197       show_source_content ();
 198       update_exec_info ();
 199       if (type == SRC_WIN)
 200         {
 201           symtab_and_line sal;
 202
 203           sal.line = line_or_addr.u.line_no + (content.size () - 2);
 204           sal.symtab = s;
 205           sal.pspace = SYMTAB_PSPACE (s);
 206           set_current_source_symtab_and_line (sal);
 207           /* If the focus was in the asm win, put it in the src win if
 208              we don't have a split layout.  */
 209           if (tui_win_with_focus () == TUI_DISASM_WIN
 210               && tui_current_layout () != SRC_DISASSEM_COMMAND)
 211             tui_set_win_focus_to (this);
 212         }
 213     }
 214 }
 215
 216
 217 /* Function to ensure that the source and/or disassemly windows
 218    reflect the input address.  */
 219 void
 220 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 221 {
 222   if (addr != 0)
 223     {
 224       struct symtab_and_line sal;
 225       struct tui_line_or_address l;
 226
 227       switch (tui_current_layout ())
 228         {
 229         case DISASSEM_COMMAND:
 230         case DISASSEM_DATA_COMMAND:
 231           tui_show_disassem (gdbarch, addr);
 232           break;
 233         case SRC_DISASSEM_COMMAND:
 234           tui_show_disassem_and_update_source (gdbarch, addr);
 235           break;
 236         default:
 237           sal = find_pc_line (addr, 0);
 238           l.loa = LOA_LINE;
 239           l.u.line_no = sal.line;
 240           TUI_SRC_WIN->show_symtab_source (gdbarch, sal.symtab, l);
 241           break;
 242         }
 243     }
 244   else
 245     {
 246       for (struct tui_source_window_base *win_info : tui_source_windows ())
 247         win_info->erase_source_content ();
 248     }
 249 }
 250
 251 /* Function to ensure that the source and/or disassemly windows
 252    reflect the input address.  */
 253 void
 254 tui_update_source_windows_with_line (struct symtab *s, int line)
 255 {
 256   struct gdbarch *gdbarch;
 257   CORE_ADDR pc;
 258   struct tui_line_or_address l;
 259
 260   if (!s)
 261     return;
 262
 263   gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
 264
 265   switch (tui_current_layout ())
 266     {
 267     case DISASSEM_COMMAND:
 268     case DISASSEM_DATA_COMMAND:
 269       find_line_pc (s, line, &pc);
 270       tui_update_source_windows_with_addr (gdbarch, pc);
 271       break;
 272     default:
 273       l.loa = LOA_LINE;
 274       l.u.line_no = line;
 275       TUI_SRC_WIN->show_symtab_source (gdbarch, s, l);
 276       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 277         {
 278           find_line_pc (s, line, &pc);
 279           tui_show_disassem (gdbarch, pc);
 280         }
 281       break;
 282     }
 283 }
 284
 285 void
 286 tui_source_window_base::do_erase_source_content (const char *str)
 287 {
 288   int x_pos;
 289   int half_width = (width - 2) / 2;
 290
 291   content.clear ();
 292   if (handle != NULL)
 293     {
 294       werase (handle.get ());
 295       check_and_display_highlight_if_needed ();
 296
 297       if (strlen (str) >= half_width)
 298         x_pos = 1;
 299       else
 300         x_pos = half_width - strlen (str);
 301       mvwaddstr (handle.get (),
 302                  (height / 2),
 303                  x_pos,
 304                  (char *) str);
 305
 306       refresh_window ();
 307     }
 308 }
 309
 310
 311 /* Redraw the complete line of a source or disassembly window.  */
 312 static void
 313 tui_show_source_line (struct tui_source_window_base *win_info, int lineno)
 314 {
 315   struct tui_source_element *line;
 316   int x;
 317
 318   line = &win_info->content[lineno - 1];
 319   if (line->is_exec_point)
 320     tui_set_reverse_mode (win_info->handle.get (), true);
 321
 322   wmove (win_info->handle.get (), lineno, TUI_EXECINFO_SIZE);
 323   tui_puts (line->line.c_str (), win_info->handle.get ());
 324   if (line->is_exec_point)
 325     tui_set_reverse_mode (win_info->handle.get (), false);
 326
 327   /* Clear to end of line but stop before the border.  */
 328   x = getcurx (win_info->handle.get ());
 329   while (x + 1 < win_info->width)
 330     {
 331       waddch (win_info->handle.get (), ' ');
 332       x = getcurx (win_info->handle.get ());
 333     }
 334 }
 335
 336 void
 337 tui_source_window_base::show_source_content ()
 338 {
 339   gdb_assert (!content.empty ());
 340
 341   for (int lineno = 1; lineno <= content.size (); lineno++)
 342     tui_show_source_line (this, lineno);
 343
 344   check_and_display_highlight_if_needed ();
 345   refresh_window ();
 346 }
 347
 348 tui_source_window_base::tui_source_window_base (enum tui_win_type type)
 349   : tui_win_info (type)
 350 {
 351   gdb_assert (type == SRC_WIN || type == DISASSEM_WIN);
 352   start_line_or_addr.loa = LOA_ADDRESS;
 353   start_line_or_addr.u.addr = 0;
 354
 355   gdb::observers::source_styling_changed.attach
 356     (std::bind (&tui_source_window::style_changed, this),
 357      m_observable);
 358 }
 359
 360 tui_source_window_base::~tui_source_window_base ()
 361 {
 362   gdb::observers::source_styling_changed.detach (m_observable);
 363 }
 364
 365 /* See tui-data.h.  */
 366
 367 void
 368 tui_source_window_base::update_tab_width ()
 369 {
 370   werase (handle.get ());
 371   rerender ();
 372 }
 373
 374 void
 375 tui_source_window_base::rerender ()
 376 {
 377   if (!content.empty ())
 378     {
 379       struct tui_line_or_address line_or_addr;
 380       struct symtab_and_line cursal
 381         = get_current_source_symtab_and_line ();
 382
 383       line_or_addr = start_line_or_addr;
 384       update_source_window (gdbarch, cursal.symtab, line_or_addr);
 385     }
 386   else if (deprecated_safe_get_selected_frame () != NULL)
 387     {
 388       struct tui_line_or_address line;
 389       struct symtab_and_line cursal
 390         = get_current_source_symtab_and_line ();
 391       struct frame_info *frame = deprecated_safe_get_selected_frame ();
 392       struct gdbarch *gdbarch = get_frame_arch (frame);
 393
 394       struct symtab *s = find_pc_line_symtab (get_frame_pc (frame));
 395       if (type == SRC_WIN)
 396         {
 397           line.loa = LOA_LINE;
 398           line.u.line_no = cursal.line;
 399         }
 400       else
 401         {
 402           line.loa = LOA_ADDRESS;
 403           find_line_pc (s, cursal.line, &line.u.addr);
 404         }
 405       update_source_window (gdbarch, s, line);
 406     }
 407   else
 408     erase_source_content ();
 409 }
 410
 411 /* See tui-data.h.  */
 412
 413 void
 414 tui_source_window_base::refill ()
 415 {
 416   symtab *s = nullptr;
 417
 418   if (type == SRC_WIN)
 419     {
 420       symtab_and_line cursal = get_current_source_symtab_and_line ();
 421       s = (cursal.symtab == NULL
 422            ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
 423            : cursal.symtab);
 424     }
 425
 426   update_source_window_as_is (gdbarch, s, content[0].line_or_addr);
 427 }
 428
 429 /* Scroll the source forward or backward horizontally.  */
 430
 431 void
 432 tui_source_window_base::do_scroll_horizontal (int num_to_scroll)
 433 {
 434   if (!content.empty ())
 435     {
 436       int offset = horizontal_offset + num_to_scroll;
 437       if (offset < 0)
 438         offset = 0;
 439       horizontal_offset = offset;
 440       refill ();
 441     }
 442 }
 443
 444
 445 /* Set or clear the is_exec_point flag in the line whose line is
 446    line_no.  */
 447
 448 void
 449 tui_source_window_base::set_is_exec_point_at (struct tui_line_or_address l)
 450 {
 451   bool changed = false;
 452   int i;
 453
 454   i = 0;
 455   while (i < content.size ())
 456     {
 457       bool new_state;
 458       struct tui_line_or_address content_loa =
 459         content[i].line_or_addr;
 460
 461       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 462       gdb_assert (content_loa.loa == LOA_LINE
 463                   || content_loa.loa == LOA_ADDRESS);
 464       if (content_loa.loa == l.loa
 465           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 466               || (l.loa == LOA_ADDRESS && content_loa.u.addr == l.u.addr)))
 467         new_state = true;
 468       else
 469         new_state = false;
 470       if (new_state != content[i].is_exec_point)
 471         {
 472           changed = true;
 473           content[i].is_exec_point = new_state;
 474           tui_show_source_line (this, i + 1);
 475         }
 476       i++;
 477     }
 478   if (changed)
 479     refill ();
 480 }
 481
 482 /* See tui-winsource.h.  */
 483
 484 void
 485 tui_update_all_breakpoint_info (struct breakpoint *being_deleted)
 486 {
 487   for (tui_source_window_base *win : tui_source_windows ())
 488     {
 489       if (win->update_breakpoint_info (being_deleted, false))
 490         win->update_exec_info ();
 491     }
 492 }
 493
 494
 495 /* Scan the source window and the breakpoints to update the break_mode
 496    information for each line.
 497
 498    Returns true if something changed and the execution window must be
 499    refreshed.  */
 500
 501 bool
 502 tui_source_window_base::update_breakpoint_info
 503   (struct breakpoint *being_deleted, bool current_only)
 504 {
 505   int i;
 506   bool need_refresh = false;
 507
 508   for (i = 0; i < content.size (); i++)
 509     {
 510       struct tui_source_element *line;
 511
 512       line = &content[i];
 513       if (current_only && !line->is_exec_point)
 514          continue;
 515
 516       /* Scan each breakpoint to see if the current line has something to
 517          do with it.  Identify enable/disabled breakpoints as well as
 518          those that we already hit.  */
 519       tui_bp_flags mode = 0;
 520       iterate_over_breakpoints ([&] (breakpoint *bp) -> bool
 521         {
 522           struct bp_location *loc;
 523
 524           gdb_assert (line->line_or_addr.loa == LOA_LINE
 525                       || line->line_or_addr.loa == LOA_ADDRESS);
 526
 527           if (bp == being_deleted)
 528             return false;
 529
 530           for (loc = bp->loc; loc != NULL; loc = loc->next)
 531             {
 532               if (location_matches_p (loc, i))
 533                 {
 534                   if (bp->enable_state == bp_disabled)
 535                     mode |= TUI_BP_DISABLED;
 536                   else
 537                     mode |= TUI_BP_ENABLED;
 538                   if (bp->hit_count)
 539                     mode |= TUI_BP_HIT;
 540                   if (bp->loc->cond)
 541                     mode |= TUI_BP_CONDITIONAL;
 542                   if (bp->type == bp_hardware_breakpoint)
 543                     mode |= TUI_BP_HARDWARE;
 544                 }
 545             }
 546           return false;
 547         });
 548       if (line->break_mode != mode)
 549         {
 550           line->break_mode = mode;
 551           need_refresh = true;
 552         }
 553     }
 554   return need_refresh;
 555 }
 556
 557 /* Function to initialize the content of the execution info window,
 558    based upon the input window which is either the source or
 559    disassembly window.  */
 560 void
 561 tui_source_window_base::update_exec_info ()
 562 {
 563   update_breakpoint_info (nullptr, true);
 564   for (int i = 0; i < content.size (); i++)
 565     {
 566       struct tui_source_element *src_element = &content[i];
 567       char element[TUI_EXECINFO_SIZE] = "   ";
 568
 569       /* Now update the exec info content based upon the state
 570          of each line as indicated by the source content.  */
 571       tui_bp_flags mode = src_element->break_mode;
 572       if (mode & TUI_BP_HIT)
 573         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 574       else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 575         element[TUI_BP_HIT_POS] = (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 576
 577       if (mode & TUI_BP_ENABLED)
 578         element[TUI_BP_BREAK_POS] = '+';
 579       else if (mode & TUI_BP_DISABLED)
 580         element[TUI_BP_BREAK_POS] = '-';
 581
 582       if (src_element->is_exec_point)
 583         element[TUI_EXEC_POS] = '>';
 584
 585       mvwaddstr (handle.get (), i + 1, 1, element);
 586     }
 587   refresh_window ();
 588 }