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