Delete pagination_enabled extern declaration in tui/tui-regs.c.
[platform/upstream/binutils.git] / gdb / tui / tui-regs.c
1 /* TUI display registers in window.
2
3    Copyright (C) 1998-2013 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 "arch-utils.h"
24 #include "tui/tui.h"
25 #include "tui/tui-data.h"
26 #include "symtab.h"
27 #include "gdbtypes.h"
28 #include "gdbcmd.h"
29 #include "frame.h"
30 #include "regcache.h"
31 #include "inferior.h"
32 #include "target.h"
33 #include "gdb_string.h"
34 #include "tui/tui-layout.h"
35 #include "tui/tui-win.h"
36 #include "tui/tui-windata.h"
37 #include "tui/tui-wingeneral.h"
38 #include "tui/tui-file.h"
39 #include "tui/tui-regs.h"
40 #include "reggroups.h"
41 #include "valprint.h"
42
43 #include "gdb_curses.h"
44
45
46 /*****************************************
47 ** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
48 ******************************************/
49 static void
50 tui_display_register (struct tui_data_element *data,
51                       struct tui_gen_win_info *win_info);
52
53 static enum tui_status tui_show_register_group (struct reggroup *group,
54                                                 struct frame_info *frame,
55                                                 int refresh_values_only);
56
57 static enum tui_status tui_get_register (struct frame_info *frame,
58                                          struct tui_data_element *data,
59                                          int regnum, int *changedp);
60
61 static void tui_register_format (struct frame_info *,
62                                  struct tui_data_element*, int);
63
64 static void tui_scroll_regs_forward_command (char *, int);
65 static void tui_scroll_regs_backward_command (char *, int);
66
67
68
69 /*****************************************
70 ** PUBLIC FUNCTIONS                     **
71 ******************************************/
72
73 /* Answer the number of the last line in the regs display.  If there
74    are no registers (-1) is returned.  */
75 int
76 tui_last_regs_line_no (void)
77 {
78   int num_lines = (-1);
79
80   if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
81     {
82       num_lines = (TUI_DATA_WIN->detail.data_display_info.regs_content_count /
83                   TUI_DATA_WIN->detail.data_display_info.regs_column_count);
84       if (TUI_DATA_WIN->detail.data_display_info.regs_content_count %
85           TUI_DATA_WIN->detail.data_display_info.regs_column_count)
86         num_lines++;
87     }
88   return num_lines;
89 }
90
91
92 /* Answer the line number that the register element at element_no is
93    on.  If element_no is greater than the number of register elements
94    there are, -1 is returned.  */
95 int
96 tui_line_from_reg_element_no (int element_no)
97 {
98   if (element_no < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
99     {
100       int i, line = (-1);
101
102       i = 1;
103       while (line == (-1))
104         {
105           if (element_no <
106               (TUI_DATA_WIN->detail.data_display_info.regs_column_count * i))
107             line = i - 1;
108           else
109             i++;
110         }
111
112       return line;
113     }
114   else
115     return (-1);
116 }
117
118
119 /* Answer the index of the first element in line_no.  If line_no is
120    past the register area (-1) is returned.  */
121 int
122 tui_first_reg_element_no_inline (int line_no)
123 {
124   if ((line_no * TUI_DATA_WIN->detail.data_display_info.regs_column_count)
125       <= TUI_DATA_WIN->detail.data_display_info.regs_content_count)
126     return ((line_no + 1) *
127             TUI_DATA_WIN->detail.data_display_info.regs_column_count) -
128       TUI_DATA_WIN->detail.data_display_info.regs_column_count;
129   else
130     return (-1);
131 }
132
133
134 /* Show the registers of the given group in the data window
135    and refresh the window.  */
136 void
137 tui_show_registers (struct reggroup *group)
138 {
139   enum tui_status ret = TUI_FAILURE;
140   struct tui_data_info *display_info;
141
142   /* Make sure the curses mode is enabled.  */
143   tui_enable ();
144
145   /* Make sure the register window is visible.  If not, select an
146      appropriate layout.  */
147   if (TUI_DATA_WIN == NULL || !TUI_DATA_WIN->generic.is_visible)
148     tui_set_layout_for_display_command (DATA_NAME);
149
150   display_info = &TUI_DATA_WIN->detail.data_display_info;
151   if (group == 0)
152     group = general_reggroup;
153
154   /* Say that registers should be displayed, even if there is a
155      problem.  */
156   display_info->display_regs = TRUE;
157
158   if (target_has_registers && target_has_stack && target_has_memory)
159     {
160       ret = tui_show_register_group (group, get_current_frame (),
161                                      group == display_info->current_group);
162     }
163   if (ret == TUI_FAILURE)
164     {
165       display_info->current_group = 0;
166       tui_erase_data_content (NO_REGS_STRING);
167     }
168   else
169     {
170       int i;
171
172       /* Clear all notation of changed values.  */
173       for (i = 0; i < display_info->regs_content_count; i++)
174         {
175           struct tui_gen_win_info *data_item_win;
176           struct tui_win_element *win;
177
178           data_item_win = &display_info->regs_content[i]
179             ->which_element.data_window;
180           win = (struct tui_win_element *) data_item_win->content[0];
181           win->which_element.data.highlight = FALSE;
182         }
183       display_info->current_group = group;
184       tui_display_all_data ();
185     }
186 }
187
188
189 /* Set the data window to display the registers of the register group
190    using the given frame.  Values are refreshed only when
191    refresh_values_only is TRUE.  */
192
193 static enum tui_status
194 tui_show_register_group (struct reggroup *group,
195                          struct frame_info *frame, 
196                          int refresh_values_only)
197 {
198   struct gdbarch *gdbarch = get_frame_arch (frame);
199   enum tui_status ret = TUI_FAILURE;
200   int nr_regs;
201   int allocated_here = FALSE;
202   int regnum, pos;
203   char title[80];
204   struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
205
206   /* Make a new title showing which group we display.  */
207   snprintf (title, sizeof (title) - 1, "Register group: %s",
208             reggroup_name (group));
209   xfree (TUI_DATA_WIN->generic.title);
210   TUI_DATA_WIN->generic.title = xstrdup (title);
211
212   /* See how many registers must be displayed.  */
213   nr_regs = 0;
214   for (regnum = 0;
215        regnum < gdbarch_num_regs (gdbarch)
216                 + gdbarch_num_pseudo_regs (gdbarch);
217        regnum++)
218     {
219       const char *name;
220
221       /* Must be in the group.  */
222       if (!gdbarch_register_reggroup_p (gdbarch, regnum, group))
223         continue;
224
225       /* If the register name is empty, it is undefined for this
226          processor, so don't display anything.  */
227       name = gdbarch_register_name (gdbarch, regnum);
228       if (name == 0 || *name == '\0')
229         continue;
230
231       nr_regs++;
232     }
233
234   if (display_info->regs_content_count > 0 && !refresh_values_only)
235     {
236       tui_free_data_content (display_info->regs_content,
237                              display_info->regs_content_count);
238       display_info->regs_content_count = 0;
239     }
240
241   if (display_info->regs_content_count <= 0)
242     {
243       display_info->regs_content = tui_alloc_content (nr_regs, DATA_WIN);
244       allocated_here = TRUE;
245       refresh_values_only = FALSE;
246     }
247
248   if (display_info->regs_content != (tui_win_content) NULL)
249     {
250       if (!refresh_values_only || allocated_here)
251         {
252           TUI_DATA_WIN->generic.content = (void*) NULL;
253           TUI_DATA_WIN->generic.content_size = 0;
254           tui_add_content_elements (&TUI_DATA_WIN->generic, nr_regs);
255           display_info->regs_content
256             = (tui_win_content) TUI_DATA_WIN->generic.content;
257           display_info->regs_content_count = nr_regs;
258         }
259
260       /* Now set the register names and values.  */
261       pos = 0;
262       for (regnum = 0;
263            regnum < gdbarch_num_regs (gdbarch)
264                     + gdbarch_num_pseudo_regs (gdbarch);
265            regnum++)
266         {
267           struct tui_gen_win_info *data_item_win;
268           struct tui_data_element *data;
269           const char *name;
270
271           /* Must be in the group.  */
272           if (!gdbarch_register_reggroup_p (gdbarch, regnum, group))
273             continue;
274
275           /* If the register name is empty, it is undefined for this
276              processor, so don't display anything.  */
277           name = gdbarch_register_name (gdbarch, regnum);
278           if (name == 0 || *name == '\0')
279             continue;
280
281           data_item_win =
282             &display_info->regs_content[pos]->which_element.data_window;
283           data = &((struct tui_win_element *)
284                    data_item_win->content[0])->which_element.data;
285           if (data)
286             {
287               if (!refresh_values_only)
288                 {
289                   data->item_no = regnum;
290                   data->name = name;
291                   data->highlight = FALSE;
292                 }
293               tui_get_register (frame, data, regnum, 0);
294             }
295           pos++;
296         }
297
298       TUI_DATA_WIN->generic.content_size =
299         display_info->regs_content_count + display_info->data_content_count;
300       ret = TUI_SUCCESS;
301     }
302
303   return ret;
304 }
305
306 /* Function to display the registers in the content from
307    'start_element_no' until the end of the register content or the end
308    of the display height.  No checking for displaying past the end of
309    the registers is done here.  */
310 void
311 tui_display_registers_from (int start_element_no)
312 {
313   struct tui_data_info *display_info = &TUI_DATA_WIN->detail.data_display_info;
314
315   if (display_info->regs_content != (tui_win_content) NULL 
316       && display_info->regs_content_count > 0)
317     {
318       int i = start_element_no;
319       int j, item_win_width, cur_y;
320
321       int max_len = 0;
322       for (i = 0; i < display_info->regs_content_count; i++)
323         {
324           struct tui_data_element *data;
325           struct tui_gen_win_info *data_item_win;
326           char *p;
327           int len;
328
329           data_item_win
330             = &display_info->regs_content[i]->which_element.data_window;
331           data = &((struct tui_win_element *)
332                    data_item_win->content[0])->which_element.data;
333           len = 0;
334           p = data->content;
335           if (p != 0)
336             while (*p)
337               {
338                 if (*p++ == '\t')
339                   len = 8 * ((len / 8) + 1);
340                 else
341                   len++;
342               }
343
344           if (len > max_len)
345             max_len = len;
346         }
347       item_win_width = max_len + 1;
348       i = start_element_no;
349
350       display_info->regs_column_count =
351         (TUI_DATA_WIN->generic.width - 2) / item_win_width;
352       if (display_info->regs_column_count == 0)
353         display_info->regs_column_count = 1;
354       item_win_width =
355         (TUI_DATA_WIN->generic.width - 2) / display_info->regs_column_count;
356
357       /* Now create each data "sub" window, and write the display into
358          it.  */
359       cur_y = 1;
360       while (i < display_info->regs_content_count 
361              && cur_y <= TUI_DATA_WIN->generic.viewport_height)
362         {
363           for (j = 0;
364                j < display_info->regs_column_count
365                  && i < display_info->regs_content_count;
366                j++)
367             {
368               struct tui_gen_win_info *data_item_win;
369               struct tui_data_element *data_element_ptr;
370
371               /* Create the window if necessary.  */
372               data_item_win = &display_info->regs_content[i]
373                 ->which_element.data_window;
374               data_element_ptr = &((struct tui_win_element *)
375                                    data_item_win->content[0])->which_element.data;
376               if (data_item_win->handle != (WINDOW*) NULL
377                   && (data_item_win->height != 1
378                       || data_item_win->width != item_win_width
379                       || data_item_win->origin.x != (item_win_width * j) + 1
380                       || data_item_win->origin.y != cur_y))
381                 {
382                   tui_delete_win (data_item_win->handle);
383                   data_item_win->handle = 0;
384                 }
385                   
386               if (data_item_win->handle == (WINDOW *) NULL)
387                 {
388                   data_item_win->height = 1;
389                   data_item_win->width = item_win_width;
390                   data_item_win->origin.x = (item_win_width * j) + 1;
391                   data_item_win->origin.y = cur_y;
392                   tui_make_window (data_item_win, DONT_BOX_WINDOW);
393                   scrollok (data_item_win->handle, FALSE);
394                 }
395               touchwin (data_item_win->handle);
396
397               /* Get the printable representation of the register
398                  and display it.  */
399               tui_display_register (data_element_ptr, data_item_win);
400               i++;              /* Next register.  */
401             }
402           cur_y++;              /* Next row.  */
403         }
404     }
405 }
406
407
408 /* Function to display the registers in the content from
409    'start_element_no' on 'start_line_no' until the end of the register
410    content or the end of the display height.  This function checks
411    that we won't display off the end of the register display.  */
412 static void
413 tui_display_reg_element_at_line (int start_element_no,
414                                  int start_line_no)
415 {
416   if (TUI_DATA_WIN->detail.data_display_info.regs_content
417       != (tui_win_content) NULL
418       && TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
419     {
420       int element_no = start_element_no;
421
422       if (start_element_no != 0 && start_line_no != 0)
423         {
424           int last_line_no, first_line_on_last_page;
425
426           last_line_no = tui_last_regs_line_no ();
427           first_line_on_last_page
428             = last_line_no - (TUI_DATA_WIN->generic.height - 2);
429           if (first_line_on_last_page < 0)
430             first_line_on_last_page = 0;
431
432           /* If there is no other data displayed except registers, and
433              the element_no causes us to scroll past the end of the
434              registers, adjust what element to really start the
435              display at.  */
436           if (TUI_DATA_WIN->detail.data_display_info.data_content_count <= 0
437               && start_line_no > first_line_on_last_page)
438             element_no
439               = tui_first_reg_element_no_inline (first_line_on_last_page);
440         }
441       tui_display_registers_from (element_no);
442     }
443 }
444
445
446
447 /* Function to display the registers starting at line line_no in the
448    data window.  Answers the line number that the display actually
449    started from.  If nothing is displayed (-1) is returned.  */
450 int
451 tui_display_registers_from_line (int line_no, 
452                                  int force_display)
453 {
454   if (TUI_DATA_WIN->detail.data_display_info.regs_content_count > 0)
455     {
456       int line, element_no;
457
458       if (line_no < 0)
459         line = 0;
460       else if (force_display)
461         { /* If we must display regs (force_display is true), then
462              make sure that we don't display off the end of the
463              registers.  */
464           if (line_no >= tui_last_regs_line_no ())
465             {
466               if ((line = tui_line_from_reg_element_no (
467                  TUI_DATA_WIN->detail.data_display_info.regs_content_count - 1)) < 0)
468                 line = 0;
469             }
470           else
471             line = line_no;
472         }
473       else
474         line = line_no;
475
476       element_no = tui_first_reg_element_no_inline (line);
477       if (element_no
478           < TUI_DATA_WIN->detail.data_display_info.regs_content_count)
479         tui_display_reg_element_at_line (element_no, line);
480       else
481         line = (-1);
482
483       return line;
484     }
485
486   return (-1);                  /* Nothing was displayed.  */
487 }
488
489
490 /* This function check all displayed registers for changes in values,
491    given a particular frame.  If the values have changed, they are
492    updated with the new value and highlighted.  */
493 void
494 tui_check_register_values (struct frame_info *frame)
495 {
496   if (TUI_DATA_WIN != NULL
497       && TUI_DATA_WIN->generic.is_visible)
498     {
499       struct tui_data_info *display_info
500         = &TUI_DATA_WIN->detail.data_display_info;
501
502       if (display_info->regs_content_count <= 0 
503           && display_info->display_regs)
504         tui_show_registers (display_info->current_group);
505       else
506         {
507           int i;
508
509           for (i = 0; (i < display_info->regs_content_count); i++)
510             {
511               struct tui_data_element *data;
512               struct tui_gen_win_info *data_item_win_ptr;
513               int was_hilighted;
514
515               data_item_win_ptr = &display_info->regs_content[i]->
516                 which_element.data_window;
517               data = &((struct tui_win_element *)
518                        data_item_win_ptr->content[0])->which_element.data;
519               was_hilighted = data->highlight;
520
521               tui_get_register (frame, data,
522                                 data->item_no, &data->highlight);
523
524               if (data->highlight || was_hilighted)
525                 {
526                   tui_display_register (data, data_item_win_ptr);
527                 }
528             }
529         }
530     }
531 }
532
533 /* Display a register in a window.  If hilite is TRUE, then the value
534    will be displayed in reverse video.  */
535 static void
536 tui_display_register (struct tui_data_element *data,
537                       struct tui_gen_win_info *win_info)
538 {
539   if (win_info->handle != (WINDOW *) NULL)
540     {
541       int i;
542
543       if (data->highlight)
544         /* We ignore the return value, casting it to void in order to avoid
545            a compiler warning.  The warning itself was introduced by a patch
546            to ncurses 5.7 dated 2009-08-29, changing this macro to expand
547            to code that causes the compiler to generate an unused-value
548            warning.  */
549         (void) wstandout (win_info->handle);
550       
551       wmove (win_info->handle, 0, 0);
552       for (i = 1; i < win_info->width; i++)
553         waddch (win_info->handle, ' ');
554       wmove (win_info->handle, 0, 0);
555       if (data->content)
556         waddstr (win_info->handle, data->content);
557
558       if (data->highlight)
559         /* We ignore the return value, casting it to void in order to avoid
560            a compiler warning.  The warning itself was introduced by a patch
561            to ncurses 5.7 dated 2009-08-29, changing this macro to expand
562            to code that causes the compiler to generate an unused-value
563            warning.  */
564         (void) wstandend (win_info->handle);
565       tui_refresh_win (win_info);
566     }
567 }
568
569 static void
570 tui_reg_next_command (char *arg, int from_tty)
571 {
572   struct gdbarch *gdbarch = get_current_arch ();
573
574   if (TUI_DATA_WIN != 0)
575     {
576       struct reggroup *group
577         = TUI_DATA_WIN->detail.data_display_info.current_group;
578
579       group = reggroup_next (gdbarch, group);
580       if (group == 0)
581         group = reggroup_next (gdbarch, 0);
582
583       if (group)
584         tui_show_registers (group);
585     }
586 }
587
588 static void
589 tui_reg_float_command (char *arg, int from_tty)
590 {
591   tui_show_registers (float_reggroup);
592 }
593
594 static void
595 tui_reg_general_command (char *arg, int from_tty)
596 {
597   tui_show_registers (general_reggroup);
598 }
599
600 static void
601 tui_reg_system_command (char *arg, int from_tty)
602 {
603   tui_show_registers (system_reggroup);
604 }
605
606 static struct cmd_list_element *tuireglist;
607
608 static void
609 tui_reg_command (char *args, int from_tty)
610 {
611   printf_unfiltered (_("\"tui reg\" must be followed by the name of a "
612                      "tui reg command.\n"));
613   help_list (tuireglist, "tui reg ", -1, gdb_stdout);
614 }
615
616 /* Provide a prototype to silence -Wmissing-prototypes.  */
617 extern initialize_file_ftype _initialize_tui_regs;
618
619 void
620 _initialize_tui_regs (void)
621 {
622   struct cmd_list_element **tuicmd;
623
624   tuicmd = tui_get_cmd_list ();
625
626   add_prefix_cmd ("reg", class_tui, tui_reg_command,
627                   _("TUI commands to control the register window."),
628                   &tuireglist, "tui reg ", 0,
629                   tuicmd);
630
631   add_cmd ("float", class_tui, tui_reg_float_command,
632            _("Display only floating point registers."),
633            &tuireglist);
634   add_cmd ("general", class_tui, tui_reg_general_command,
635            _("Display only general registers."),
636            &tuireglist);
637   add_cmd ("system", class_tui, tui_reg_system_command,
638            _("Display only system registers."),
639            &tuireglist);
640   add_cmd ("next", class_tui, tui_reg_next_command,
641            _("Display next register group."),
642            &tuireglist);
643
644   if (xdb_commands)
645     {
646       add_com ("fr", class_tui, tui_reg_float_command,
647                _("Display only floating point registers\n"));
648       add_com ("gr", class_tui, tui_reg_general_command,
649                _("Display only general registers\n"));
650       add_com ("sr", class_tui, tui_reg_system_command,
651                _("Display only special registers\n"));
652       add_com ("+r", class_tui, tui_scroll_regs_forward_command,
653                _("Scroll the registers window forward\n"));
654       add_com ("-r", class_tui, tui_scroll_regs_backward_command,
655                _("Scroll the register window backward\n"));
656     }
657 }
658
659
660 /*****************************************
661 ** STATIC LOCAL FUNCTIONS                 **
662 ******************************************/
663
664 static void
665 tui_restore_gdbout (void *ui)
666 {
667   ui_file_delete (gdb_stdout);
668   gdb_stdout = (struct ui_file*) ui;
669   pagination_enabled = 1;
670 }
671
672 /* Get the register from the frame and make a printable representation
673    of it in the data element.  */
674 static void
675 tui_register_format (struct frame_info *frame,
676                      struct tui_data_element *data_element, 
677                      int regnum)
678 {
679   struct gdbarch *gdbarch = get_frame_arch (frame);
680   struct ui_file *stream;
681   struct ui_file *old_stdout;
682   const char *name;
683   struct cleanup *cleanups;
684   char *p, *s;
685
686   name = gdbarch_register_name (gdbarch, regnum);
687   if (name == 0 || *name == '\0')
688     return;
689
690   pagination_enabled = 0;
691   old_stdout = gdb_stdout;
692   stream = tui_sfileopen (256);
693   gdb_stdout = stream;
694   cleanups = make_cleanup (tui_restore_gdbout, (void*) old_stdout);
695   gdbarch_print_registers_info (gdbarch, stream, frame, regnum, 1);
696
697   /* Save formatted output in the buffer.  */
698   p = tui_file_get_strbuf (stream);
699
700   /* Remove the possible \n.  */
701   s = strrchr (p, '\n');
702   if (s && s[1] == 0)
703     *s = 0;
704
705   xfree (data_element->content);
706   data_element->content = xstrdup (p);
707   do_cleanups (cleanups);
708 }
709
710 /* Get the register value from the given frame and format it for the
711    display.  When changep is set, check if the new register value has
712    changed with respect to the previous call.  */
713 static enum tui_status
714 tui_get_register (struct frame_info *frame,
715                   struct tui_data_element *data, 
716                   int regnum, int *changedp)
717 {
718   enum tui_status ret = TUI_FAILURE;
719
720   if (changedp)
721     *changedp = FALSE;
722   if (target_has_registers)
723     {
724       struct value *old_val = data->value;
725
726       data->value = get_frame_register_value (frame, regnum);
727       release_value (data->value);
728       if (changedp)
729         {
730           struct gdbarch *gdbarch = get_frame_arch (frame);
731           int size = register_size (gdbarch, regnum);
732
733           /* We only know whether a value chunk is available if we've
734              tried to read it.  */
735           if (value_lazy (data->value))
736             value_fetch_lazy (data->value);
737           if (value_lazy (old_val))
738             value_fetch_lazy (old_val);
739
740           if (value_optimized_out (data->value) != value_optimized_out (old_val)
741               || !value_available_contents_eq (data->value, 0,
742                                                old_val, 0, size))
743             *changedp = TRUE;
744         }
745
746       value_free (old_val);
747
748       /* Reformat the data content if the value changed.  */
749       if (changedp == 0 || *changedp == TRUE)
750         tui_register_format (frame, data, regnum);
751
752       ret = TUI_SUCCESS;
753     }
754   return ret;
755 }
756
757 static void
758 tui_scroll_regs_forward_command (char *arg, int from_tty)
759 {
760   tui_scroll (FORWARD_SCROLL, TUI_DATA_WIN, 1);
761 }
762
763
764 static void
765 tui_scroll_regs_backward_command (char *arg, int from_tty)
766 {
767   tui_scroll (BACKWARD_SCROLL, TUI_DATA_WIN, 1);
768 }