gdb/tui: add a tui debugging flag

This commit adds 'set debug tui on|off' and 'show debug tui'.  This
commit adds the control variable, and the printing macros in
tui/tui.h.  I've then added some uses of these in tui.c and
tui-layout.c.

To help produce more useful debug output in tui-layout.c, I've added
some helper member functions in the class tui_layout_split, and also
moved the size_info struct out of tui_layout_split::apply into the
tui_layout_split class.

If tui debug is not turned on, then there should be no user visible
changes after this commit.

One thing to note is that, due to the way that the tui terminal is
often cleared, the only way I've found this useful is when I do:

  (gdb) tui enable
  (gdb) set logging file /path/to/file
  (gdb) set logging debugredirect on
  (gdb) set logging enable on

Additionally, gdb has some quirks when it comes to setting up logging
redirect and switching interpreters.  Thus, the above only really
works if the logging is enabled after the tui is enabled, and disabled
again before the tui is disabled.

Enabling logging and switching interpreters can cause undefined
results, including crashes.  This is an existing bug in gdb[1], and
has nothing directly to do with tui debug, but it is worth mentioning
here I think.

[1] https://sourceware.org/bugzilla/show_bug.cgi?id=28948

diff --git a/gdb/NEWS b/gdb/NEWS
index b1c4d9540100e22d1f0f05f9a2b0dbc3a31de014..d76157128beeaf980f0e020e680273e1bf4b48fd 100644 (file)
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -154,6 +154,10 @@ winwidth
   the width of a tui window to be adjusted when windows are laid out
   in horizontal mode.
 
+set debug tui on|off
+show debug tui
+  Control the display of debug output about GDB's tui.
+
 * Changed commands
 
 print

diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index 0e80ab8e45d005716cccb9da84454a71660cf5c4..af025175521d22fdf6a0b33af50c90df71a03b03 100644 (file)
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -29204,6 +29204,17 @@ The default display uses more space for line numbers and starts the
 source text at the next tab stop; the compact display uses only as
 much space as is needed for the line numbers in the current file, and
 only a single space to separate the line numbers from the source.
+
+@kindex set debug tui
+@item set debug tui @r{[}on|off@r{]}
+Turn on or off display of @value{GDBN} internal debug messages relating
+to the TUI.
+
+@kindex show debug tui
+@item show debug tui
+Show the current status of displaying @value{GDBN} internal debug
+messages relating to the TUI.
+
 @end table
 
 Note that the colors of the TUI borders can be controlled using the

diff --git a/gdb/tui/tui-layout.c b/gdb/tui/tui-layout.c
index 239c966fd5c91c5c8a790494325b4d51d88e1544..6fd176d9235760eb12acd09ac3bac9f5bf710811 100644 (file)
--- a/gdb/tui/tui-layout.c
+++ b/gdb/tui/tui-layout.c
@@ -426,8 +426,14 @@ tui_layout_window::apply (int x_, int y_, int width_, int height_)
 void
 tui_layout_window::get_sizes (bool height, int *min_value, int *max_value)
 {
+  TUI_SCOPED_DEBUG_ENTER_EXIT;
+
   if (m_window == nullptr)
     m_window = tui_get_window_by_name (m_contents);
+
+  tui_debug_printf ("window = %s, getting %s",
+                   m_window->name (), (height ? "height" : "width"));
+
   if (height)
     {
       *min_value = m_window->min_height ();
@@ -438,6 +444,8 @@ tui_layout_window::get_sizes (bool height, int *min_value, int *max_value)
       *min_value = m_window->min_width ();
       *max_value = m_window->max_width ();
     }
+
+  tui_debug_printf ("min = %d, max = %d", *min_value, *max_value);
 }
 
 /* See tui-layout.h.  */
@@ -522,6 +530,8 @@ tui_layout_split::clone () const
 void
 tui_layout_split::get_sizes (bool height, int *min_value, int *max_value)
 {
+  TUI_SCOPED_DEBUG_ENTER_EXIT;
+
   *min_value = 0;
   *max_value = 0;
   bool first_time = true;
@@ -544,6 +554,8 @@ tui_layout_split::get_sizes (bool height, int *min_value, int *max_value)
        }
       first_time = false;
     }
+
+  tui_debug_printf ("min_value = %d, max_value = %d", *min_value, *max_value);
 }
 
 /* See tui-layout.h.  */
@@ -578,9 +590,46 @@ tui_layout_split::set_weights_from_sizes ()
 
 /* See tui-layout.h.  */
 
+std::string
+tui_layout_split::tui_debug_weights_to_string () const
+{
+  std::string str;
+
+  for (int i = 0; i < m_splits.size (); ++i)
+    {
+      if (i > 0)
+       str += ", ";
+      str += string_printf ("[%d] %d", i, m_splits[i].weight);
+    }
+
+  return str;
+}
+
+/* See tui-layout.h.  */
+
+void
+tui_layout_split::tui_debug_print_size_info
+  (const std::vector<tui_layout_split::size_info> &info)
+{
+  gdb_assert (debug_tui);
+
+  tui_debug_printf ("current size info data:");
+  for (int i = 0; i < info.size (); ++i)
+    tui_debug_printf ("  [%d] { size = %d, min = %d, max = %d, share_box = %d }",
+                     i, info[i].size, info[i].min_size,
+                     info[i].max_size, info[i].share_box);
+}
+
+/* See tui-layout.h.  */
+
 tui_adjust_result
 tui_layout_split::set_size (const char *name, int new_size, bool set_width_p)
 {
+  TUI_SCOPED_DEBUG_ENTER_EXIT;
+
+  tui_debug_printf ("this = %p, name = %s, new_size = %d",
+                   this, name, new_size);
+
   /* Look through the children.  If one is a layout holding the named
      window, we're done; or if one actually is the named window,
      update it.  */
@@ -611,10 +660,15 @@ tui_layout_split::set_size (const char *name, int new_size, bool set_width_p)
   if (curr_size == new_size)
     return HANDLED;
 
+  tui_debug_printf ("found window %s at index %d", name, found_index);
+
   set_weights_from_sizes ();
   int delta = m_splits[found_index].weight - new_size;
   m_splits[found_index].weight = new_size;
 
+  tui_debug_printf ("before delta (%d) distribution, weights: %s",
+                   delta, tui_debug_weights_to_string ().c_str ());
+
   /* Distribute the "delta" over the next window; but if the next
      window cannot hold it all, keep going until we either find a
      window that does, or until we loop all the way around.  */
@@ -643,8 +697,14 @@ tui_layout_split::set_size (const char *name, int new_size, bool set_width_p)
          m_splits[index].weight += grow_by;
          delta -= grow_by;
        }
+
+      tui_debug_printf ("index = %d, weight now: %d",
+                       index, m_splits[index].weight);
     }
 
+  tui_debug_printf ("after delta (%d) distribution, weights: %s",
+                   delta, tui_debug_weights_to_string ().c_str ());
+
   if (delta != 0)
     {
       if (set_width_p)
@@ -668,23 +728,18 @@ tui_layout_split::set_size (const char *name, int new_size, bool set_width_p)
 void
 tui_layout_split::apply (int x_, int y_, int width_, int height_)
 {
+  TUI_SCOPED_DEBUG_ENTER_EXIT;
+
   x = x_;
   y = y_;
   width = width_;
   height = height_;
 
-  struct size_info
-  {
-    int size;
-    int min_size;
-    int max_size;
-    /* True if this window will share a box border with the previous
-       window in the list.  */
-    bool share_box;
-  };
-
   std::vector<size_info> info (m_splits.size ());
 
+  tui_debug_printf ("weights are: %s",
+                   tui_debug_weights_to_string ().c_str ());
+
   /* Step 1: Find the min and max size of each sub-layout.
      Fixed-sized layouts are given their desired size, and then the
      remaining space is distributed among the remaining windows
@@ -760,9 +815,31 @@ tui_layout_split::apply (int x_, int y_, int width_, int height_)
        }
     }
 
+  if (debug_tui)
+    {
+      tui_debug_printf ("after initial size calculation");
+      tui_debug_printf ("available_size = %d, used_size = %d",
+                       available_size, used_size);
+      tui_debug_printf ("total_weight = %d, last_index = %d",
+                       total_weight, last_index);
+      tui_debug_print_size_info (info);
+    }
+
   /* Allocate any leftover size.  */
   if (available_size >= used_size && last_index != -1)
-    info[last_index].size += available_size - used_size;
+    {
+      info[last_index].size += available_size - used_size;
+
+      if (debug_tui)
+       {
+         tui_debug_printf ("after final size calculation");
+         tui_debug_printf ("available_size = %d, used_size = %d",
+                           available_size, used_size);
+         tui_debug_printf ("total_weight = %d, last_index = %d",
+                           total_weight, last_index);
+         tui_debug_print_size_info (info);
+       }
+    }
 
   /* Step 3: Resize.  */
   int size_accum = 0;

diff --git a/gdb/tui/tui-layout.h b/gdb/tui/tui-layout.h
index 79ad0b8dafc2e63686d348ffa9b541b86f5fafbd..26de3c3a97943a4649c1cbef9461e0f95c0edeb1 100644 (file)
--- a/gdb/tui/tui-layout.h
+++ b/gdb/tui/tui-layout.h
@@ -249,6 +249,31 @@ private:
      widths (when m_vertical is false).  */
   void set_weights_from_sizes ();
 
+  /* Structure used when resizing, or applying a layout.  An instance of
+     this structure is created for each sub-layout.  */
+  struct size_info
+  {
+    /* The calculated size for this sub-layout.  */
+    int size;
+
+    /* The minimum and maximum sizes for this sub-layout, obtained by
+       calling the get_sizes member function.  */
+    int min_size;
+    int max_size;
+
+    /* True if this window will share a box border with the previous
+       window in the list.  */
+    bool share_box;
+  };
+
+  /* Used for debug, prints the contents of INFO using tui_debug_printf.
+     Only call this when the global debug_tui is true.  */
+  static void tui_debug_print_size_info (const std::vector<size_info> &info);
+
+  /* Used for debug, returns a string describing the current weight of each
+     sub-layout.  */
+  std::string tui_debug_weights_to_string () const;
+
   struct split
   {
     /* The requested weight.  */

diff --git a/gdb/tui/tui.c b/gdb/tui/tui.c
index 776dccf0bb2034e0f5487de65805b7b01dcc0376..45be33786e32da8c90986484268f86534f4a6bdb 100644 (file)
--- a/gdb/tui/tui.c
+++ b/gdb/tui/tui.c
@@ -50,6 +50,19 @@
 #include "gdb_curses.h"
 #include "interps.h"
 
+/* See tui.h.  */
+
+bool debug_tui = false;
+
+/* Implement 'show debug tui'.  */
+
+static void
+show_tui_debug (struct ui_file *file, int from_tty,
+               struct cmd_list_element *c, const char *value)
+{
+  gdb_printf (file, _("TUI debugging is \"%s\".\n"), value);
+}
+
 /* This redefines CTRL if it is not already defined, so it must come
    after terminal state releated include files like <term.h> and
    "gdb_curses.h".  */
@@ -354,6 +367,8 @@ gdb_getenv_term (void)
 void
 tui_enable (void)
 {
+  TUI_SCOPED_DEBUG_ENTER_EXIT;
+
   if (tui_active)
     return;
 
@@ -494,6 +509,8 @@ tui_enable (void)
 void
 tui_disable (void)
 {
+  TUI_SCOPED_DEBUG_ENTER_EXIT;
+
   if (!tui_active)
     return;
 
@@ -587,4 +604,13 @@ Usage: tui enable"),
           _("Disable TUI display mode.\n\
 Usage: tui disable"),
           tuicmd);
+
+  /* Debug this tui internals.  */
+  add_setshow_boolean_cmd ("tui", class_maintenance, &debug_tui,  _("\
+Set tui debugging."), _("\
+Show tui debugging."), _("\
+When true, tui specific internal debugging is enabled."),
+                          NULL,
+                          show_tui_debug,
+                          &setdebuglist, &showdebuglist);
 }

diff --git a/gdb/tui/tui.h b/gdb/tui/tui.h
index a4df66f17fcb793f4ad56c4009bd01a62cab807b..924d91daa7ec1cab4085ef34fe8a7889258fd8e2 100644 (file)
--- a/gdb/tui/tui.h
+++ b/gdb/tui/tui.h
@@ -22,6 +22,20 @@
 #ifndef TUI_TUI_H
 #define TUI_TUI_H
 
+/* Flag to control tui debugging.  */
+
+extern bool debug_tui;
+
+/* Print a "tui" debug statement.  */
+
+#define tui_debug_printf(fmt, ...) \
+  debug_prefixed_printf_cond (debug_tui, "tui", fmt, ##__VA_ARGS__)
+
+/* Print "tui" enter/exit debug statements.  */
+
+#define TUI_SCOPED_DEBUG_ENTER_EXIT \
+  scoped_debug_enter_exit (debug_tui, "tui")
+
 struct ui_file;
 
 /* Types of error returns.  */