gdb/tui/tui-winsource.c

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