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