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