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   if (!tui_source_windows ().empty ())
  48     {
  49       struct gdbarch *gdbarch;
  50       CORE_ADDR addr;
  51
  52       tui_get_begin_asm_address (&gdbarch, &addr);
  53       if (addr != (CORE_ADDR) 0)
  54         {
  55           struct symtab *s;
  56
  57           tui_update_source_windows_with_addr (gdbarch, addr);
  58           s = find_pc_line_symtab (addr);
  59           if (s != NULL)
  60              tui_update_locator_fullname (symtab_to_fullname (s));
  61           else
  62              tui_update_locator_fullname ("??");
  63         }
  64     }
  65 }
  66
  67
  68
  69 /* Function to display source in the source window.  This function
  70    initializes the horizontal scroll to 0.  */
  71 void
  72 tui_update_source_window (struct tui_win_info *win_info,
  73                           struct gdbarch *gdbarch,
  74                           struct symtab *s,
  75                           struct tui_line_or_address line_or_addr,
  76                           int noerror)
  77 {
  78   win_info->detail.source_info.horizontal_offset = 0;
  79   tui_update_source_window_as_is (win_info, gdbarch, s, line_or_addr, noerror);
  80
  81   return;
  82 }
  83
  84
  85 /* Function to display source in the source/asm window.  This function
  86    shows the source as specified by the horizontal offset.  */
  87 void
  88 tui_update_source_window_as_is (struct tui_win_info *win_info,
  89                                 struct gdbarch *gdbarch,
  90                                 struct symtab *s,
  91                                 struct tui_line_or_address line_or_addr,
  92                                 int noerror)
  93 {
  94   enum tui_status ret;
  95
  96   if (win_info->generic.type == SRC_WIN)
  97     ret = tui_set_source_content (s, line_or_addr.u.line_no, noerror);
  98   else
  99     ret = tui_set_disassem_content (gdbarch, line_or_addr.u.addr);
 100
 101   if (ret == TUI_FAILURE)
 102     {
 103       tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 104       tui_clear_exec_info_content (win_info);
 105     }
 106   else
 107     {
 108       tui_update_breakpoint_info (win_info, 0);
 109       tui_show_source_content (win_info);
 110       tui_update_exec_info (win_info);
 111       if (win_info->generic.type == SRC_WIN)
 112         {
 113           symtab_and_line sal;
 114
 115           sal.line = line_or_addr.u.line_no +
 116             (win_info->generic.content_size - 2);
 117           sal.symtab = s;
 118           sal.pspace = SYMTAB_PSPACE (s);
 119           set_current_source_symtab_and_line (sal);
 120           /* If the focus was in the asm win, put it in the src win if
 121              we don't have a split layout.  */
 122           if (tui_win_with_focus () == TUI_DISASM_WIN
 123               && tui_current_layout () != SRC_DISASSEM_COMMAND)
 124             tui_set_win_focus_to (TUI_SRC_WIN);
 125         }
 126     }
 127
 128
 129   return;
 130 }
 131
 132
 133 /* Function to ensure that the source and/or disassemly windows
 134    reflect the input address.  */
 135 void
 136 tui_update_source_windows_with_addr (struct gdbarch *gdbarch, CORE_ADDR addr)
 137 {
 138   if (addr != 0)
 139     {
 140       struct symtab_and_line sal;
 141       struct tui_line_or_address l;
 142
 143       switch (tui_current_layout ())
 144         {
 145         case DISASSEM_COMMAND:
 146         case DISASSEM_DATA_COMMAND:
 147           tui_show_disassem (gdbarch, addr);
 148           break;
 149         case SRC_DISASSEM_COMMAND:
 150           tui_show_disassem_and_update_source (gdbarch, addr);
 151           break;
 152         default:
 153           sal = find_pc_line (addr, 0);
 154           l.loa = LOA_LINE;
 155           l.u.line_no = sal.line;
 156           tui_show_symtab_source (gdbarch, sal.symtab, l, FALSE);
 157           break;
 158         }
 159     }
 160   else
 161     {
 162       for (struct tui_win_info *win_info : tui_source_windows ())
 163         {
 164           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 165           tui_clear_exec_info_content (win_info);
 166         }
 167     }
 168 }
 169
 170 /* Function to ensure that the source and/or disassemly windows
 171    reflect the input address.  */
 172 void
 173 tui_update_source_windows_with_line (struct symtab *s, int line)
 174 {
 175   struct gdbarch *gdbarch;
 176   CORE_ADDR pc;
 177   struct tui_line_or_address l;
 178
 179   if (!s)
 180     return;
 181
 182   gdbarch = get_objfile_arch (SYMTAB_OBJFILE (s));
 183
 184   switch (tui_current_layout ())
 185     {
 186     case DISASSEM_COMMAND:
 187     case DISASSEM_DATA_COMMAND:
 188       find_line_pc (s, line, &pc);
 189       tui_update_source_windows_with_addr (gdbarch, pc);
 190       break;
 191     default:
 192       l.loa = LOA_LINE;
 193       l.u.line_no = line;
 194       tui_show_symtab_source (gdbarch, s, l, FALSE);
 195       if (tui_current_layout () == SRC_DISASSEM_COMMAND)
 196         {
 197           find_line_pc (s, line, &pc);
 198           tui_show_disassem (gdbarch, pc);
 199         }
 200       break;
 201     }
 202
 203   return;
 204 }
 205
 206 void
 207 tui_clear_source_content (struct tui_win_info *win_info,
 208                           int display_prompt)
 209 {
 210   if (win_info != NULL)
 211     {
 212       int i;
 213
 214       win_info->generic.content_in_use = FALSE;
 215       tui_erase_source_content (win_info, display_prompt);
 216       for (i = 0; i < win_info->generic.content_size; i++)
 217         {
 218           struct tui_win_element *element = win_info->generic.content[i];
 219
 220           element->which_element.source.has_break = FALSE;
 221           element->which_element.source.is_exec_point = FALSE;
 222         }
 223     }
 224 }
 225
 226
 227 void
 228 tui_erase_source_content (struct tui_win_info *win_info,
 229                           int display_prompt)
 230 {
 231   int x_pos;
 232   int half_width = (win_info->generic.width - 2) / 2;
 233
 234   if (win_info->generic.handle != NULL)
 235     {
 236       werase (win_info->generic.handle);
 237       tui_check_and_display_highlight_if_needed (win_info);
 238       if (display_prompt == EMPTY_SOURCE_PROMPT)
 239         {
 240           const char *no_src_str;
 241
 242           if (win_info->generic.type == SRC_WIN)
 243             no_src_str = NO_SRC_STRING;
 244           else
 245             no_src_str = NO_DISASSEM_STRING;
 246           if (strlen (no_src_str) >= half_width)
 247             x_pos = 1;
 248           else
 249             x_pos = half_width - strlen (no_src_str);
 250           mvwaddstr (win_info->generic.handle,
 251                      (win_info->generic.height / 2),
 252                      x_pos,
 253                      (char *) no_src_str);
 254
 255           /* elz: Added this function call to set the real contents of
 256              the window to what is on the screen, so that later calls
 257              to refresh, do display the correct stuff, and not the old
 258              image.  */
 259
 260           tui_set_source_content_nil (win_info, no_src_str);
 261         }
 262       tui_refresh_win (&win_info->generic);
 263     }
 264 }
 265
 266
 267 /* Redraw the complete line of a source or disassembly window.  */
 268 static void
 269 tui_show_source_line (struct tui_win_info *win_info, int lineno)
 270 {
 271   struct tui_win_element *line;
 272   int x;
 273
 274   line = win_info->generic.content[lineno - 1];
 275   if (line->which_element.source.is_exec_point)
 276     tui_set_reverse_mode (win_info->generic.handle, true);
 277
 278   wmove (win_info->generic.handle, lineno, 1);
 279   tui_puts (line->which_element.source.line,
 280             win_info->generic.handle);
 281   if (line->which_element.source.is_exec_point)
 282     tui_set_reverse_mode (win_info->generic.handle, false);
 283
 284   /* Clear to end of line but stop before the border.  */
 285   x = getcurx (win_info->generic.handle);
 286   while (x + 1 < win_info->generic.width)
 287     {
 288       waddch (win_info->generic.handle, ' ');
 289       x = getcurx (win_info->generic.handle);
 290     }
 291 }
 292
 293 void
 294 tui_show_source_content (struct tui_win_info *win_info)
 295 {
 296   if (win_info->generic.content_size > 0)
 297     {
 298       int lineno;
 299
 300       for (lineno = 1; lineno <= win_info->generic.content_size; lineno++)
 301         tui_show_source_line (win_info, lineno);
 302     }
 303   else
 304     tui_erase_source_content (win_info, TRUE);
 305
 306   tui_check_and_display_highlight_if_needed (win_info);
 307   tui_refresh_win (&win_info->generic);
 308   win_info->generic.content_in_use = TRUE;
 309 }
 310
 311 /* Refill the source window's source cache and update it.  If WIN_INFO
 312    is a disassembly window, then just update it.  */
 313
 314 void
 315 tui_refill_source_window (struct tui_win_info *win_info)
 316 {
 317   symtab *s = nullptr;
 318
 319   if (win_info->generic.type == SRC_WIN)
 320     {
 321       symtab_and_line cursal = get_current_source_symtab_and_line ();
 322       s = (cursal.symtab == NULL
 323            ? find_pc_line_symtab (get_frame_pc (get_selected_frame (NULL)))
 324            : cursal.symtab);
 325     }
 326
 327   tui_update_source_window_as_is (win_info,
 328                                   win_info->detail.source_info.gdbarch,
 329                                   s,
 330                                   win_info->generic.content[0]
 331                                     ->which_element.source.line_or_addr,
 332                                   FALSE);
 333 }
 334
 335 /* Scroll the source forward or backward horizontally.  */
 336
 337 void
 338 tui_horizontal_source_scroll (struct tui_win_info *win_info,
 339                               enum tui_scroll_direction direction,
 340                               int num_to_scroll)
 341 {
 342   if (win_info->generic.content != NULL)
 343     {
 344       int offset;
 345
 346       if (direction == LEFT_SCROLL)
 347         offset = win_info->detail.source_info.horizontal_offset
 348           + num_to_scroll;
 349       else
 350         {
 351           offset = win_info->detail.source_info.horizontal_offset
 352             - num_to_scroll;
 353           if (offset < 0)
 354             offset = 0;
 355         }
 356       win_info->detail.source_info.horizontal_offset = offset;
 357       tui_refill_source_window (win_info);
 358     }
 359 }
 360
 361
 362 /* Set or clear the has_break flag in the line whose line is
 363    line_no.  */
 364
 365 void
 366 tui_set_is_exec_point_at (struct tui_line_or_address l,
 367                           struct tui_win_info *win_info)
 368 {
 369   int changed = 0;
 370   int i;
 371   tui_win_content content = win_info->generic.content;
 372
 373   i = 0;
 374   while (i < win_info->generic.content_size)
 375     {
 376       int new_state;
 377       struct tui_line_or_address content_loa =
 378         content[i]->which_element.source.line_or_addr;
 379
 380       gdb_assert (l.loa == LOA_ADDRESS || l.loa == LOA_LINE);
 381       gdb_assert (content_loa.loa == LOA_LINE
 382                   || content_loa.loa == LOA_ADDRESS);
 383       if (content_loa.loa == l.loa
 384           && ((l.loa == LOA_LINE && content_loa.u.line_no == l.u.line_no)
 385               || (content_loa.u.addr == l.u.addr)))
 386         new_state = TRUE;
 387       else
 388         new_state = FALSE;
 389       if (new_state != content[i]->which_element.source.is_exec_point)
 390         {
 391           changed++;
 392           content[i]->which_element.source.is_exec_point = new_state;
 393           tui_show_source_line (win_info, i + 1);
 394         }
 395       i++;
 396     }
 397   if (changed)
 398     tui_refill_source_window (win_info);
 399 }
 400
 401 /* Update the execution windows to show the active breakpoints.
 402    This is called whenever a breakpoint is inserted, removed or
 403    has its state changed.  */
 404 void
 405 tui_update_all_breakpoint_info ()
 406 {
 407   for (tui_win_info *win : tui_source_windows ())
 408     {
 409       if (tui_update_breakpoint_info (win, FALSE))
 410         {
 411           tui_update_exec_info (win);
 412         }
 413     }
 414 }
 415
 416
 417 /* Scan the source window and the breakpoints to update the has_break
 418    information for each line.
 419
 420    Returns 1 if something changed and the execution window must be
 421    refreshed.  */
 422
 423 int
 424 tui_update_breakpoint_info (struct tui_win_info *win,
 425                             int current_only)
 426 {
 427   int i;
 428   int need_refresh = 0;
 429   struct tui_source_info *src = &win->detail.source_info;
 430
 431   for (i = 0; i < win->generic.content_size; i++)
 432     {
 433       struct breakpoint *bp;
 434       extern struct breakpoint *breakpoint_chain;
 435       int mode;
 436       struct tui_source_element *line;
 437
 438       line = &win->generic.content[i]->which_element.source;
 439       if (current_only && !line->is_exec_point)
 440          continue;
 441
 442       /* Scan each breakpoint to see if the current line has something to
 443          do with it.  Identify enable/disabled breakpoints as well as
 444          those that we already hit.  */
 445       mode = 0;
 446       for (bp = breakpoint_chain;
 447            bp != NULL;
 448            bp = bp->next)
 449         {
 450           struct bp_location *loc;
 451
 452           gdb_assert (line->line_or_addr.loa == LOA_LINE
 453                       || line->line_or_addr.loa == LOA_ADDRESS);
 454
 455           for (loc = bp->loc; loc != NULL; loc = loc->next)
 456             {
 457               if ((win == TUI_SRC_WIN
 458                    && loc->symtab != NULL
 459                    && filename_cmp (src->fullname,
 460                                     symtab_to_fullname (loc->symtab)) == 0
 461                    && line->line_or_addr.loa == LOA_LINE
 462                    && loc->line_number == line->line_or_addr.u.line_no)
 463                   || (win == TUI_DISASM_WIN
 464                       && line->line_or_addr.loa == LOA_ADDRESS
 465                       && loc->address == line->line_or_addr.u.addr))
 466                 {
 467                   if (bp->enable_state == bp_disabled)
 468                     mode |= TUI_BP_DISABLED;
 469                   else
 470                     mode |= TUI_BP_ENABLED;
 471                   if (bp->hit_count)
 472                     mode |= TUI_BP_HIT;
 473                   if (bp->loc->cond)
 474                     mode |= TUI_BP_CONDITIONAL;
 475                   if (bp->type == bp_hardware_breakpoint)
 476                     mode |= TUI_BP_HARDWARE;
 477                 }
 478             }
 479         }
 480       if (line->has_break != mode)
 481         {
 482           line->has_break = mode;
 483           need_refresh = 1;
 484         }
 485     }
 486   return need_refresh;
 487 }
 488
 489
 490 /* Function to initialize the content of the execution info window,
 491    based upon the input window which is either the source or
 492    disassembly window.  */
 493 enum tui_status
 494 tui_set_exec_info_content (struct tui_win_info *win_info)
 495 {
 496   enum tui_status ret = TUI_SUCCESS;
 497
 498   if (win_info->detail.source_info.execution_info != NULL)
 499     {
 500       struct tui_gen_win_info *exec_info_ptr
 501         = win_info->detail.source_info.execution_info;
 502
 503       if (exec_info_ptr->content == NULL)
 504         exec_info_ptr->content =
 505           tui_alloc_content (win_info->generic.height, exec_info_ptr->type);
 506       if (exec_info_ptr->content != NULL)
 507         {
 508           int i;
 509
 510           tui_update_breakpoint_info (win_info, 1);
 511           for (i = 0; i < win_info->generic.content_size; i++)
 512             {
 513               struct tui_win_element *element;
 514               struct tui_win_element *src_element;
 515               int mode;
 516
 517               element = exec_info_ptr->content[i];
 518               src_element = win_info->generic.content[i];
 519
 520               memset(element->which_element.simple_string, ' ',
 521                      sizeof(element->which_element.simple_string));
 522               element->which_element.simple_string[TUI_EXECINFO_SIZE - 1] = 0;
 523
 524               /* Now update the exec info content based upon the state
 525                  of each line as indicated by the source content.  */
 526               mode = src_element->which_element.source.has_break;
 527               if (mode & TUI_BP_HIT)
 528                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 529                   (mode & TUI_BP_HARDWARE) ? 'H' : 'B';
 530               else if (mode & (TUI_BP_ENABLED | TUI_BP_DISABLED))
 531                 element->which_element.simple_string[TUI_BP_HIT_POS] =
 532                   (mode & TUI_BP_HARDWARE) ? 'h' : 'b';
 533
 534               if (mode & TUI_BP_ENABLED)
 535                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '+';
 536               else if (mode & TUI_BP_DISABLED)
 537                 element->which_element.simple_string[TUI_BP_BREAK_POS] = '-';
 538
 539               if (src_element->which_element.source.is_exec_point)
 540                 element->which_element.simple_string[TUI_EXEC_POS] = '>';
 541             }
 542           exec_info_ptr->content_size = win_info->generic.content_size;
 543         }
 544       else
 545         ret = TUI_FAILURE;
 546     }
 547
 548   return ret;
 549 }
 550
 551
 552 void
 553 tui_show_exec_info_content (struct tui_win_info *win_info)
 554 {
 555   struct tui_gen_win_info *exec_info
 556     = win_info->detail.source_info.execution_info;
 557   int cur_line;
 558
 559   werase (exec_info->handle);
 560   tui_refresh_win (exec_info);
 561   for (cur_line = 1; (cur_line <= exec_info->content_size); cur_line++)
 562     mvwaddstr (exec_info->handle,
 563                cur_line,
 564                0,
 565                (char *) exec_info->content[cur_line - 1]
 566                           ->which_element.simple_string);
 567   tui_refresh_win (exec_info);
 568   exec_info->content_in_use = TRUE;
 569 }
 570
 571
 572 void
 573 tui_erase_exec_info_content (struct tui_win_info *win_info)
 574 {
 575   struct tui_gen_win_info *exec_info
 576     = win_info->detail.source_info.execution_info;
 577
 578   werase (exec_info->handle);
 579   tui_refresh_win (exec_info);
 580 }
 581
 582 void
 583 tui_clear_exec_info_content (struct tui_win_info *win_info)
 584 {
 585   win_info->detail.source_info.execution_info->content_in_use = FALSE;
 586   tui_erase_exec_info_content (win_info);
 587
 588   return;
 589 }
 590
 591 /* Function to update the execution info window.  */
 592 void
 593 tui_update_exec_info (struct tui_win_info *win_info)
 594 {
 595   tui_set_exec_info_content (win_info);
 596   tui_show_exec_info_content (win_info);
 597 }
 598
 599 enum tui_status
 600 tui_alloc_source_buffer (struct tui_win_info *win_info)
 601 {
 602   int i, line_width, max_lines;
 603
 604   /* The window width/height includes the highlight box.  Determine actual
 605      content dimensions, including string null-terminators.  */
 606   max_lines = win_info->generic.height - 2;
 607   line_width = win_info->generic.width - 2 + 1;
 608
 609   /* Allocate the buffer for the source lines.  */
 610   if (win_info->generic.content == NULL)
 611     {
 612       /* Allocate the content list.  */
 613       win_info->generic.content = tui_alloc_content (max_lines, SRC_WIN);
 614       for (i = 0; i < max_lines; i++)
 615         win_info->generic.content[i]->which_element.source.line
 616           = (char *) xmalloc (line_width);
 617     }
 618
 619   return TUI_SUCCESS;
 620 }
 621
 622
 623 /* Answer whether a particular line number or address is displayed
 624    in the current source window.  */
 625 int
 626 tui_line_is_displayed (int line,
 627                        struct tui_win_info *win_info,
 628                        int check_threshold)
 629 {
 630   int is_displayed = FALSE;
 631   int i, threshold;
 632
 633   if (check_threshold)
 634     threshold = SCROLL_THRESHOLD;
 635   else
 636     threshold = 0;
 637   i = 0;
 638   while (i < win_info->generic.content_size - threshold
 639          && !is_displayed)
 640     {
 641       is_displayed
 642         = win_info->generic.content[i]
 643             ->which_element.source.line_or_addr.loa == LOA_LINE
 644           && win_info->generic.content[i]
 645                ->which_element.source.line_or_addr.u.line_no == line;
 646       i++;
 647     }
 648
 649   return is_displayed;
 650 }
 651
 652
 653 /* Answer whether a particular line number or address is displayed
 654    in the current source window.  */
 655 int
 656 tui_addr_is_displayed (CORE_ADDR addr,
 657                        struct tui_win_info *win_info,
 658                        int check_threshold)
 659 {
 660   int is_displayed = FALSE;
 661   int i, threshold;
 662
 663   if (check_threshold)
 664     threshold = SCROLL_THRESHOLD;
 665   else
 666     threshold = 0;
 667   i = 0;
 668   while (i < win_info->generic.content_size - threshold
 669          && !is_displayed)
 670     {
 671       is_displayed
 672         = win_info->generic.content[i]
 673             ->which_element.source.line_or_addr.loa == LOA_ADDRESS
 674           && win_info->generic.content[i]
 675                ->which_element.source.line_or_addr.u.addr == addr;
 676       i++;
 677     }
 678
 679   return is_displayed;
 680 }
 681
 682
 683 /*****************************************
 684 ** STATIC LOCAL FUNCTIONS               **
 685 ******************************************/