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