[PATCH] gdb: Allow struct fields named double

[Andrew Burgess <andrew.burgess@embecosm.com>]

The patch below fixes an issue with the current was floating point is
handled on RISC-V.  We currently model 64-bit floating point as a
union with fields 'double' and 'float'.  The problem is that having a
field named 'double' isn't currently valid in GDB (though float is fine).

The easiest solution might be to change the field names... but the
patch below instead extends the C parser to allow double as a field
name.

I'd be interested in hearing feedback on the below,

Thanks,
Andrew

---

The 64-bit RISC-V target currently models the floating point registers
as having the following type:

    union riscv_double
    {
        builtin_type_ieee_single float;
        builtin_type_ieee_double double;
    }

Notice the choice of names for the fields of this struct, possibly not
ideal choices, as these are not valid field names in C.  However, this
type is only ever defined within GDB (or in the target description),
and no restriction seems to exist on the field names in that case.

The problem though is that currently:

    (gdb) info registers $ft0
    ft0            {float = 0, double = 0}	(raw 0x0000000000000000)
    (gdb) p $ft0.float
    $1 = 0
    (gdb) p $ft0.double
    A syntax error in expression, near `double'.

We can access the 'float' field, but not the 'double' field.  This is
because the string 'double' is handled differently to the string
'float' in c-exp.y.

In both cases the string '$ft0' is parsed as a VARIABLE expression.

In the 'float' case, the string 'float' becomes a generic NAME token
in 'lex_one_token', which then allows the rule "exp '.' name" to match
and the field name lookup to occur.

The 'double' case is different.  In order to allow parsing of the type
string 'long double', the 'double' string becomes the token
DOUBLE_KEYWORD.  At this point there's no rule to match "exp '.'
DOUBLE_KEYWORD", so we can never lookup the field named 'double'.

We could rename the fields for RISC-V, and maybe that would be the
best solution.  However, its not hard to allow for fields named
'double', which is what this patch does.

A new case is added to the 'name' rule to match the DOUBLE_KEYWORD,
and create a suitable 'struct stoken'.  With this done the "exp '.'
name" pattern can now match, and we can lookup the double field.

With this patch in place I now see this behaviour:

    (gdb) info registers $ft0
    ft0            {float = 0, double = 0}	(raw 0x0000000000000000)
    (gdb) p $ft0.float
    $1 = 0
    (gdb) p $ft0.double
    $2 = 0

This change was tested on x86-64 GNU/Linux with no regressions.

gdb/ChangeLog:

	* c-exp.y (name): Allow DOUBLE_KEYWORD to act as a name.
	(typename_stoken): New function.
---
 gdb/ChangeLog |  5 +++++
 gdb/c-exp.y   | 17 +++++++++++++++++
 2 files changed, 22 insertions(+)

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index bfc78415b22..8d805cbde3d 100644
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -113,6 +113,7 @@ static int type_aggregate_p (struct type *);
 static int parse_number (struct parser_state *par_state,
 			 const char *, int, int, YYSTYPE *);
 static struct stoken operator_stoken (const char *);
+static struct stoken typename_stoken (const char *);
 static void check_parameter_typelist (VEC (type_ptr) *);
 static void write_destructor_name (struct parser_state *par_state,
 				   struct stoken);
@@ -1642,6 +1643,7 @@ name	:	NAME { $$ = $1.stoken; }
 	|	TYPENAME { $$ = $1.stoken; }
 	|	NAME_OR_INT  { $$ = $1.stoken; }
 	|	UNKNOWN_CPP_NAME  { $$ = $1.stoken; }
+	|	DOUBLE_KEYWORD { $$ = typename_stoken ("double"); }
 	|	oper { $$ = $1; }
 	;
 
@@ -1707,6 +1709,21 @@ operator_stoken (const char *op)
   return st;
 };
 
+/* Returns a stoken of the type named TYPE.  */
+
+static struct stoken
+typename_stoken (const char *type)
+{
+  struct stoken st = { NULL, 0 };
+  char *buf = xstrdup (type);
+  st.ptr = buf;
+  st.length = strlen (type);
+
+  /* The toplevel (c_parse) will free the memory allocated here.  */
+  make_cleanup (free, buf);
+  return st;
+};
+
 /* Return true if the type is aggregate-like.  */
 
 static int
-- 
2.14.5