Change how complex types are printed in C

[deliverable/binutils-gdb.git] / gdb / c-exp.y

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 47e82b698b418e467f114b03dc1400c0a3e297a7..a4efaab79c8142277d9a1405a5dea087c4c33aef 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -1,5 +1,5 @@
 /* YACC parser for C expressions, for GDB.
-   Copyright (C) 1986-2019 Free Software Foundation, Inc.
+   Copyright (C) 1986-2020 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -237,6 +237,7 @@ static void c_print_token (FILE *file, int type, YYSTYPE value);
 /* Special type cases, put in to allow the parser to distinguish different
    legal basetypes.  */
 %token SIGNED_KEYWORD LONG SHORT INT_KEYWORD CONST_KEYWORD VOLATILE_KEYWORD DOUBLE_KEYWORD
+%token RESTRICT ATOMIC
 
 %token <sval> DOLLAR_VARIABLE
 
@@ -824,7 +825,6 @@ exp :       SIZEOF '(' type ')'     %prec UNARY
                          write_exp_elt_opcode (pstate, OP_LONG);
                          write_exp_elt_type (pstate, lookup_signed_typename
                                              (pstate->language (),
-                                              pstate->gdbarch (),
                                               "int"));
                          type = check_typedef (type);
 
@@ -1170,36 +1170,43 @@ variable:       name_not_typename
                        }
        ;
 
-space_identifier : '@' NAME
-               {
-                 cpstate->type_stack.insert (pstate,
-                                             copy_name ($2.stoken).c_str ());
-               }
-       ;
-
 const_or_volatile: const_or_volatile_noopt
        |
        ;
 
-cv_with_space_id : const_or_volatile space_identifier const_or_volatile
+single_qualifier:
+               CONST_KEYWORD
+                       { cpstate->type_stack.insert (tp_const); }
+       |       VOLATILE_KEYWORD
+                       { cpstate->type_stack.insert (tp_volatile); }
+       |       ATOMIC
+                       { cpstate->type_stack.insert (tp_atomic); }
+       |       RESTRICT
+                       { cpstate->type_stack.insert (tp_restrict); }
+       |       '@' NAME
+               {
+                 cpstate->type_stack.insert (pstate,
+                                             copy_name ($2.stoken).c_str ());
+               }
        ;
 
-const_or_volatile_or_space_identifier_noopt: cv_with_space_id
-       | const_or_volatile_noopt
+qualifier_seq_noopt:
+               single_qualifier
+       |       qualifier_seq single_qualifier
        ;
 
-const_or_volatile_or_space_identifier:
-               const_or_volatile_or_space_identifier_noopt
+qualifier_seq:
+               qualifier_seq_noopt
        |
        ;
 
 ptr_operator:
                ptr_operator '*'
                        { cpstate->type_stack.insert (tp_pointer); }
-               const_or_volatile_or_space_identifier
+               qualifier_seq
        |       '*'
                        { cpstate->type_stack.insert (tp_pointer); }
-               const_or_volatile_or_space_identifier
+               qualifier_seq
        |       '&'
                        { cpstate->type_stack.insert (tp_reference); }
        |       '&' ptr_operator
@@ -1301,117 +1308,89 @@ typebase
                        { $$ = $1.type; }
        |       INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "int"); }
        |       LONG
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long"); }
        |       SHORT
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "short"); }
        |       LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long"); }
        |       LONG SIGNED_KEYWORD INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long"); }
        |       LONG SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long"); }
        |       SIGNED_KEYWORD LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long"); }
        |       UNSIGNED LONG INT_KEYWORD
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "long"); }
        |       LONG UNSIGNED INT_KEYWORD
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "long"); }
        |       LONG UNSIGNED
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "long"); }
        |       LONG LONG
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       LONG LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       UNSIGNED LONG LONG
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       UNSIGNED LONG LONG INT_KEYWORD
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       LONG LONG UNSIGNED
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       LONG LONG UNSIGNED INT_KEYWORD
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       SHORT INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "short"); }
        |       SHORT SIGNED_KEYWORD INT_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "short"); }
        |       SHORT SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "short"); }
        |       UNSIGNED SHORT INT_KEYWORD
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "short"); }
        |       SHORT UNSIGNED
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "short"); }
        |       SHORT UNSIGNED INT_KEYWORD
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "short"); }
        |       DOUBLE_KEYWORD
                        { $$ = lookup_typename (pstate->language (),
-                                               pstate->gdbarch (),
                                                "double",
                                                NULL,
                                                0); }
        |       LONG DOUBLE_KEYWORD
                        { $$ = lookup_typename (pstate->language (),
-                                               pstate->gdbarch (),
                                                "long double",
                                                NULL,
                                                0); }
@@ -1483,19 +1462,15 @@ typebase
                        }
        |       UNSIGNED type_name
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         TYPE_NAME($2.type)); }
        |       UNSIGNED
                        { $$ = lookup_unsigned_typename (pstate->language (),
-                                                        pstate->gdbarch (),
                                                         "int"); }
        |       SIGNED_KEYWORD type_name
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       TYPE_NAME($2.type)); }
        |       SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (pstate->language (),
-                                                      pstate->gdbarch (),
                                                       "int"); }
                 /* It appears that this rule for templates is never
                    reduced; template recognition happens by lookahead
@@ -1505,9 +1480,9 @@ typebase
                            (copy_name($2).c_str (), $4,
                             pstate->expression_context_block);
                        }
-       | const_or_volatile_or_space_identifier_noopt typebase
+       |       qualifier_seq_noopt typebase
                        { $$ = cpstate->type_stack.follow_types ($2); }
-       | typebase const_or_volatile_or_space_identifier_noopt
+       |       typebase qualifier_seq_noopt
                        { $$ = cpstate->type_stack.follow_types ($1); }
        ;
 
@@ -1517,7 +1492,6 @@ type_name:        TYPENAME
                  $$.stoken.ptr = "int";
                  $$.stoken.length = 3;
                  $$.type = lookup_signed_typename (pstate->language (),
-                                                   pstate->gdbarch (),
                                                    "int");
                }
        |       LONG
@@ -1525,7 +1499,6 @@ type_name:        TYPENAME
                  $$.stoken.ptr = "long";
                  $$.stoken.length = 4;
                  $$.type = lookup_signed_typename (pstate->language (),
-                                                   pstate->gdbarch (),
                                                    "long");
                }
        |       SHORT
@@ -1533,7 +1506,6 @@ type_name:        TYPENAME
                  $$.stoken.ptr = "short";
                  $$.stoken.length = 5;
                  $$.type = lookup_signed_typename (pstate->language (),
-                                                   pstate->gdbarch (),
                                                    "short");
                }
        ;
@@ -2381,11 +2353,15 @@ enum token_flag
 
   FLAG_CXX = 1,
 
+  /* If this bit is set, the token is C-only.  */
+
+  FLAG_C = 2,
+
   /* If this bit is set, the token is conditional: if there is a
      symbol of the same name, then the token is a symbol; otherwise,
      the token is a keyword.  */
 
-  FLAG_SHADOW = 2
+  FLAG_SHADOW = 4
 };
 DEF_ENUM_FLAGS_TYPE (enum token_flag, token_flags);
 
@@ -2452,6 +2428,10 @@ static const struct token ident_tokens[] =
     {"union", UNION, OP_NULL, 0},
     {"short", SHORT, OP_NULL, 0},
     {"const", CONST_KEYWORD, OP_NULL, 0},
+    {"restrict", RESTRICT, OP_NULL, FLAG_C | FLAG_SHADOW},
+    {"__restrict__", RESTRICT, OP_NULL, 0},
+    {"__restrict", RESTRICT, OP_NULL, 0},
+    {"_Atomic", ATOMIC, OP_NULL, 0},
     {"enum", ENUM, OP_NULL, 0},
     {"long", LONG, OP_NULL, 0},
     {"true", TRUEKEYWORD, OP_NULL, FLAG_CXX},
@@ -2490,15 +2470,14 @@ static const struct token ident_tokens[] =
 static void
 scan_macro_expansion (char *expansion)
 {
-  char *copy;
+  const char *copy;
 
   /* We'd better not be trying to push the stack twice.  */
   gdb_assert (! cpstate->macro_original_text);
 
   /* Copy to the obstack, and then free the intermediate
      expansion.  */
-  copy = (char *) obstack_copy0 (&cpstate->expansion_obstack, expansion,
-                                strlen (expansion));
+  copy = obstack_strdup (&cpstate->expansion_obstack, expansion);
   xfree (expansion);
 
   /* Save the old lexptr value, so we can return to it when we're done
@@ -2587,6 +2566,7 @@ lex_one_token (struct parser_state *par_state, bool *is_quoted_name)
        if ((tokentab3[i].flags & FLAG_CXX) != 0
            && par_state->language ()->la_language != language_cplus)
          break;
+       gdb_assert ((tokentab3[i].flags & FLAG_C) == 0);
 
        pstate->lexptr += 3;
        yylval.opcode = tokentab3[i].opcode;
@@ -2600,6 +2580,7 @@ lex_one_token (struct parser_state *par_state, bool *is_quoted_name)
        if ((tokentab2[i].flags & FLAG_CXX) != 0
            && par_state->language ()->la_language != language_cplus)
          break;
+       gdb_assert ((tokentab2[i].flags & FLAG_C) == 0);
 
        pstate->lexptr += 2;
        yylval.opcode = tokentab2[i].opcode;
@@ -2894,6 +2875,10 @@ lex_one_token (struct parser_state *par_state, bool *is_quoted_name)
        if ((ident_tokens[i].flags & FLAG_CXX) != 0
            && par_state->language ()->la_language != language_cplus)
          break;
+       if ((ident_tokens[i].flags & FLAG_C) != 0
+           && par_state->language ()->la_language != language_c
+           && par_state->language ()->la_language != language_objc)
+         break;
 
        if ((ident_tokens[i].flags & FLAG_SHADOW) != 0)
          {
@@ -3292,9 +3277,9 @@ yylex (void)
   if (checkpoint > 0)
     {
       current.value.sval.ptr
-       = (const char *) obstack_copy0 (&cpstate->expansion_obstack,
-                                       current.value.sval.ptr,
-                                       current.value.sval.length);
+       = obstack_strndup (&cpstate->expansion_obstack,
+                          current.value.sval.ptr,
+                          current.value.sval.length);
 
       token_fifo[0] = current;
       if (checkpoint > 1)
@@ -3394,7 +3379,7 @@ c_print_token (FILE *file, int type, YYSTYPE value)
       parser_fprintf (file, "ssym<name=%s, sym=%s, field_of_this=%d>",
                       copy_name (value.ssym.stoken).c_str (),
                       (value.ssym.sym.symbol == NULL
-                       ? "(null)" : SYMBOL_PRINT_NAME (value.ssym.sym.symbol)),
+                       ? "(null)" : value.ssym.sym.symbol->print_name ()),
                       value.ssym.is_a_field_of_this);
       break;