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