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