espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-17 07:53:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

gdb: Introduce setting construct within cmd_list_element

Browse Source 
cmd_list_element can contain a pointer to data that can be set and / or
shown.  This is achieved with the void* VAR member which points to the
data that can be accessed, while the VAR_TYPE member (of type enum
var_types) indicates how to interpret the data pointed to.

With this pattern, the user of the cmd_list_element needs to know what
is the storage type associated with a given VAR_TYPES in order to do
the proper casting.  No automatic safeguard is available to prevent
miss-use of the pointer.  Client code typically looks something like:

	switch (c->var_type)
	{
	  case var_zuinteger:
	    unsigned int v = *(unsigned int*) c->var;
	    ...
	    break;
	  case var_boolean:
	    bool v = *(bool *) c->var;
	    ...
	    break;
	  ...
	}

This patch proposes to add an abstraction around the var_types and void*
pointer pair.  The abstraction is meant to prevent the user from having
to handle the cast and verify that the data is read or written as a type
that is coherent with the setting's var_type.  This is achieved by
introducing the struct setting which exposes a set of templated get /
set member functions.  The template parameter is the type of the
variable that holds the referred variable.

Using those accessors allows runtime checks to be inserted in order to
ensure that the data pointed to has the expected type.  For example,
instantiating the member functions with bool will yield something
similar to:

	const bool &get<bool> () const
	{
	  gdb_assert (m_var_type == var_boolean);
	  gdb_assert (m_var != nullptr);
	  return *static_cast<bool *> (m_var);
	}
	void set<bool> (const bool &var)
	{
	  gdb_assert (m_var_type == var_boolean);
	  gdb_assert (m_var != nullptr);
	  *static_cast<bool *> (m_var) = var;
	}

Using the new abstraction, our initial example becomes:

	switch (c->var_type)
	{
	  case var_zuinteger:
	    unsigned int v = c->var->get<unsigned int> ();
	    ...
	    break;
	  case var_boolean:
	    bool v = c->var->get<bool> ();
	    ...
	    break;
	  ...
	}

While the call site is still similar, the introduction of runtime checks
help ensure correct usage of the data.

In order to avoid turning the bulk of add_setshow_cmd_full into a
templated function, and following a suggestion from Pedro Alves, a
setting can be constructed from a pre validated type erased reference to
a variable.  This is what setting::erased_args is used for.

Introducing an opaque abstraction to describe a setting will also make
it possible to use callbacks to retrieve or set the value of the setting
on the fly instead of pointing to a static chunk of memory.  This will
be done added in a later commit.

Given that a cmd_list_element may or may not reference a setting, the
VAR and VAR_TYPES members of the struct are replaced with a
gdb::optional<setting> named VAR.

Few internal function signatures have been modified to take into account
this new abstraction:

-The functions value_from_setting, str_value_from_setting and
 get_setshow_command_value_string used to have a 'cmd_list_element *'
 parameter but only used it for the VAR and VAR_TYPE member. They now
 take a 'const setting &' parameter instead.
- Similarly, the 'void *' and a 'enum var_types' parameters of
  pascm_param_value and gdbpy_parameter_value have been replaced with a
  'const setting &' parameter.

No user visible change is expected after this patch.

Tested on GNU/Linux x86_64, with no regression noticed.

Co-authored-by: Simon Marchi <simon.marchi@polymtl.ca>
Change-Id: Ie1d08c3ceb8b30b3d7bf1efe036eb8acffcd2f34
This commit is contained in:
Lancelot SIX
2021-09-13 22:32:19 +01:00
parent 39d53d0435
commit 1d7fe7f01b
14 changed files with 547 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
gdb/cli/cli-setshow.c
View File

@ -130,10 +130,14 @@ deprecated_show_value_hack (struct ui_file *ignore_file,
/* If there's no command or value, don't try to print it out. */
if (c == NULL || value == NULL)
return;
/* Print doc minus "Show " at start. Tell print_doc_line that
this is for a 'show value' prefix. */
print_doc_line (gdb_stdout, c->doc + 5, true);
switch (c->var_type)
gdb_assert (c->var.has_value ());
switch (c->var->type ())
{
case var_string:
case var_string_noescape:
@ -142,6 +146,7 @@ deprecated_show_value_hack (struct ui_file *ignore_file,
case var_enum:
printf_filtered ((" is \"%s\".\n"), value);
break;
default:
printf_filtered ((" is %s.\n"), value);
break;
@ -312,7 +317,9 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
if (arg == NULL)
arg = "";
switch (c->var_type)
gdb_assert (c->var.has_value ());
switch (c->var->type ())
{
case var_string:
{
@ -353,11 +360,12 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
*q++ = '\0';
newobj = (char *) xrealloc (newobj, q - newobj);
if (*(char **) c->var == NULL
|| strcmp (*(char **) c->var, newobj) != 0)
char * const var = c->var->get<char *> ();
if (var == nullptr
|| strcmp (var, newobj) != 0)
{
xfree (*(char **) c->var);
*(char **) c->var = newobj;
xfree (var);
c->var->set<char *> (newobj);
option_changed = true;
}
@ -366,13 +374,17 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
}
break;
case var_string_noescape:
if (*(char **) c->var == NULL || strcmp (*(char **) c->var, arg) != 0)
{
xfree (*(char **) c->var);
*(char **) c->var = xstrdup (arg);
{
char * const var = c->var->get<char *> ();
if (var == nullptr
|| strcmp (var, arg) != 0)
{
xfree (var);
c->var->set<char *> (xstrdup (arg));
option_changed = true;
}
option_changed = true;
}
}
break;
case var_filename:
if (*arg == '\0')
@ -398,11 +410,12 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
else
val = xstrdup ("");
if (*(char **) c->var == NULL
|| strcmp (*(char **) c->var, val) != 0)
char * const var = c->var->get<char *> ();
if (var == nullptr
|| strcmp (var, val) != 0)
{
xfree (*(char **) c->var);
*(char **) c->var = val;
xfree (var);
c->var->set<char *> (val);
option_changed = true;
}
@ -416,9 +429,9 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
if (val < 0)
error (_("\"on\" or \"off\" expected."));
if (val != *(bool *) c->var)
if (val != c->var->get<bool> ())
{
*(bool *) c->var = val;
c->var->set<bool> (val);
option_changed = true;
}
@ -428,9 +441,9 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
{
enum auto_boolean val = parse_auto_binary_operation (arg);
if (*(enum auto_boolean *) c->var != val)
if (c->var->get<enum auto_boolean> () != val)
{
*(enum auto_boolean *) c->var = val;
c->var->set<enum auto_boolean> (val);
option_changed = true;
}
@ -439,11 +452,12 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
case var_uinteger:
case var_zuinteger:
{
unsigned int val = parse_cli_var_uinteger (c->var_type, &arg, true);
unsigned int val
= parse_cli_var_uinteger (c->var->type (), &arg, true);
if (*(unsigned int *) c->var != val)
if (c->var->get<unsigned int> () != val)
{
*(unsigned int *) c->var = val;
c->var->set<unsigned int> (val);
option_changed = true;
}
@ -456,35 +470,35 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
if (*arg == '\0')
{
if (c->var_type == var_integer)
if (c->var->type () == var_integer)
error_no_arg (_("integer to set it to, or \"unlimited\"."));
else
error_no_arg (_("integer to set it to."));
}
if (c->var_type == var_integer && is_unlimited_literal (&arg, true))
if (c->var->type () == var_integer && is_unlimited_literal (&arg, true))
val = 0;
else
val = parse_and_eval_long (arg);
if (val == 0 && c->var_type == var_integer)
if (val == 0 && c->var->type () == var_integer)
val = INT_MAX;
else if (val < INT_MIN
/* For var_integer, don't let the user set the value
to INT_MAX directly, as that exposes an
implementation detail to the user interface. */
|| (c->var_type == var_integer && val >= INT_MAX)
|| (c->var_type == var_zinteger && val > INT_MAX))
|| (c->var->type () == var_integer && val >= INT_MAX)
|| (c->var->type () == var_zinteger && val > INT_MAX))
error (_("integer %s out of range"), plongest (val));
if (*(int *) c->var != val)
if (c->var->get<int> () != val)
{
*(int *) c->var = val;
c->var->set<int> (val);
option_changed = true;
}
break;
}
break;
case var_enum:
{
const char *end_arg = arg;
@ -495,9 +509,9 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
if (*after != '\0')
error (_("Junk after item \"%.*s\": %s"), len, arg, after);
if (*(const char **) c->var != match)
if (c->var->get<const char *> () != match)
{
*(const char **) c->var = match;
c->var->set<const char *> (match);
option_changed = true;
}
@ -507,9 +521,9 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
{
int val = parse_cli_var_zuinteger_unlimited (&arg, true);
if (*(int *) c->var != val)
if (c->var->get<int> () != val)
{
*(int *) c->var = val;
c->var->set<int> (val);
option_changed = true;
}
}
@ -578,25 +592,33 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
xfree (cmds);
switch (c->var_type)
switch (c->var->type ())
{
case var_string:
case var_string_noescape:
case var_filename:
case var_optional_filename:
case var_enum:
gdb::observers::command_param_changed.notify (name, *(char **) c->var);
{
const char *var;
if (c->var->type () == var_enum)
var = c->var->get<const char *> ();
else
var = c->var->get<char *> ();
gdb::observers::command_param_changed.notify (name, var);
}
break;
case var_boolean:
{
const char *opt = *(bool *) c->var ? "on" : "off";
const char *opt = c->var->get<bool> () ? "on" : "off";
gdb::observers::command_param_changed.notify (name, opt);
}
break;
case var_auto_boolean:
{
const char *s = auto_boolean_enums[*(enum auto_boolean *) c->var];
const char *s
= auto_boolean_enums[c->var->get<enum auto_boolean> ()];
gdb::observers::command_param_changed.notify (name, s);
}
@ -606,7 +628,7 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
{
char s[64];
xsnprintf (s, sizeof s, "%u", *(unsigned int *) c->var);
xsnprintf (s, sizeof s, "%u", c->var->get<unsigned int> ());
gdb::observers::command_param_changed.notify (name, s);
}
break;
@ -616,7 +638,7 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
{
char s[64];
xsnprintf (s, sizeof s, "%d", *(int *) c->var);
xsnprintf (s, sizeof s, "%d", c->var->get<int> ());
gdb::observers::command_param_changed.notify (name, s);
}
break;
@ -628,28 +650,40 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
/* See cli/cli-setshow.h. */
std::string
get_setshow_command_value_string (const cmd_list_element *c)
get_setshow_command_value_string (const setting &var)
{
string_file stb;
switch (c->var_type)
switch (var.type ())
{
case var_string:
if (*(char **) c->var)
stb.putstr (*(char **) c->var, '"');
{
char *value = var.get<char *> ();
if (value != nullptr)
stb.putstr (value, '"');
}
break;
case var_string_noescape:
case var_optional_filename:
case var_filename:
case var_enum:
if (*(char **) c->var)
stb.puts (*(char **) c->var);
{
const char *value;
if (var.type () == var_enum)
value = var.get<const char *> ();
else
value = var.get<char *> ();
if (value != nullptr)
stb.puts (value);
}
break;
case var_boolean:
stb.puts (*(bool *) c->var ? "on" : "off");
stb.puts (var.get<bool> () ? "on" : "off");
break;
case var_auto_boolean:
switch (*(enum auto_boolean*) c->var)
switch (var.get<enum auto_boolean> ())
{
case AUTO_BOOLEAN_TRUE:
stb.puts ("on");
@ -667,26 +701,35 @@ get_setshow_command_value_string (const cmd_list_element *c)
break;
case var_uinteger:
case var_zuinteger:
if (c->var_type == var_uinteger
&& *(unsigned int *) c->var == UINT_MAX)
stb.puts ("unlimited");
else
stb.printf ("%u", *(unsigned int *) c->var);
{
const unsigned int value = var.get<unsigned int> ();
if (var.type () == var_uinteger
&& value == UINT_MAX)
stb.puts ("unlimited");
else
stb.printf ("%u", value);
}
break;
case var_integer:
case var_zinteger:
if (c->var_type == var_integer
&& *(int *) c->var == INT_MAX)
stb.puts ("unlimited");
else
stb.printf ("%d", *(int *) c->var);
{
const int value = var.get<int> ();
if (var.type () == var_integer
&& value == INT_MAX)
stb.puts ("unlimited");
else
stb.printf ("%d", value);
}
break;
case var_zuinteger_unlimited:
{
if (*(int *) c->var == -1)
const int value = var.get<int> ();
if (value == -1)
stb.puts ("unlimited");
else
stb.printf ("%d", *(int *) c->var);
stb.printf ("%d", value);
}
break;
default:
@ -708,8 +751,9 @@ do_show_command (const char *arg, int from_tty, struct cmd_list_element *c)
struct ui_out *uiout = current_uiout;
gdb_assert (c->type == show_cmd);
gdb_assert (c->var.has_value ());
std::string val = get_setshow_command_value_string (c);
std::string val = get_setshow_command_value_string (*c->var);
/* FIXME: cagney/2005-02-10: There should be MI and CLI specific
versions of code to print the value out. */