Turn parse_gdbarch into a method

This changes parse_gdbarch into a method of parser_state.  This patch
was written by a script.

gdb/ChangeLog
2019-04-04  Tom Tromey  <tom@tromey.com>

	* rust-exp.y: Replace "parse_gdbarch" with method call.
	* parse.c (write_dollar_variable, insert_type_address_space):
	Replace "parse_gdbarch" with method call.
	* p-exp.y (parse_type, yylex): Replace "parse_gdbarch" with method
	call.
	* objc-lang.c (end_msglist): Replace "parse_gdbarch" with method
	call.
	* m2-exp.y (parse_type, parse_m2_type, yylex): Replace
	"parse_gdbarch" with method call.
	* go-exp.y (parse_type, classify_name): Replace "parse_gdbarch"
	with method call.
	* f-exp.y (parse_type, parse_f_type, yylex): Replace
	"parse_gdbarch" with method call.
	* d-exp.y (parse_type, parse_d_type, lex_one_token): Replace
	"parse_gdbarch" with method call.
	* c-exp.y (parse_type, parse_number, classify_name): Replace
	"parse_gdbarch" with method call.
	* ada-lex.l: Replace "parse_gdbarch" with method call.
	* ada-exp.y (parse_type, find_primitive_type, type_char)
	(type_system_address): Replace "parse_gdbarch" with method call.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ae7c5df26aa25cbe235fdbe0000e9b2e67875b73..7495f6152d388ccd6dcb622706659d452666a758 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,26 @@
+2019-04-04  Tom Tromey  <tom@tromey.com>
+
+       * rust-exp.y: Replace "parse_gdbarch" with method call.
+       * parse.c (write_dollar_variable, insert_type_address_space):
+       Replace "parse_gdbarch" with method call.
+       * p-exp.y (parse_type, yylex): Replace "parse_gdbarch" with method
+       call.
+       * objc-lang.c (end_msglist): Replace "parse_gdbarch" with method
+       call.
+       * m2-exp.y (parse_type, parse_m2_type, yylex): Replace
+       "parse_gdbarch" with method call.
+       * go-exp.y (parse_type, classify_name): Replace "parse_gdbarch"
+       with method call.
+       * f-exp.y (parse_type, parse_f_type, yylex): Replace
+       "parse_gdbarch" with method call.
+       * d-exp.y (parse_type, parse_d_type, lex_one_token): Replace
+       "parse_gdbarch" with method call.
+       * c-exp.y (parse_type, parse_number, classify_name): Replace
+       "parse_gdbarch" with method call.
+       * ada-lex.l: Replace "parse_gdbarch" with method call.
+       * ada-exp.y (parse_type, find_primitive_type, type_char)
+       (type_system_address): Replace "parse_gdbarch" with method call.
+
 2019-04-04  Tom Tromey  <tom@tromey.com>
 
        * dtrace-probe.c (dtrace_probe::build_arg_exprs): Update.

diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y
index 5925416e88fc8f5fc49f4f46d3bb1147ec015e4a..74dab760cf874efdd5a8ebec1ee5570f405da64a 100644 (file)
--- a/gdb/ada-exp.y
+++ b/gdb/ada-exp.y
@@ -48,7 +48,7 @@
 #include "frame.h"
 #include "block.h"
 
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
    etc).  */
@@ -1028,7 +1028,7 @@ find_primitive_type (struct parser_state *par_state, char *name)
 {
   struct type *type;
   type = language_lookup_primitive_type (parse_language (par_state),
-                                        parse_gdbarch (par_state),
+                                        par_state->gdbarch (),
                                         name);
   if (type == NULL && strcmp ("system__address", name) == 0)
     type = type_system_address (par_state);
@@ -1443,7 +1443,7 @@ static struct type *
 type_char (struct parser_state *par_state)
 {
   return language_string_char_type (parse_language (par_state),
-                                   parse_gdbarch (par_state));
+                                   par_state->gdbarch ());
 }
 
 static struct type *
@@ -1457,7 +1457,7 @@ type_system_address (struct parser_state *par_state)
 {
   struct type *type 
     = language_lookup_primitive_type (parse_language (par_state),
-                                     parse_gdbarch (par_state),
+                                     par_state->gdbarch (),
                                      "system__address");
   return  type != NULL ? type : parse_type (par_state)->builtin_data_ptr;
 }

diff --git a/gdb/ada-lex.l b/gdb/ada-lex.l
index 05af013c258c50c737486a049108b3c9704432f6..17ac7e5d3d5d099b73904216089406b481a320d7 100644 (file)
--- a/gdb/ada-lex.l
+++ b/gdb/ada-lex.l
@@ -370,11 +370,11 @@ processInt (struct parser_state *par_state, const char *base0,
       exp -= 1;
     }
 
-  if ((result >> (gdbarch_int_bit (parse_gdbarch (par_state))-1)) == 0)
+  if ((result >> (gdbarch_int_bit (par_state->gdbarch ())-1)) == 0)
     yylval.typed_val.type = type_int (par_state);
-  else if ((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) == 0)
+  else if ((result >> (gdbarch_long_bit (par_state->gdbarch ())-1)) == 0)
     yylval.typed_val.type = type_long (par_state);
-  else if (((result >> (gdbarch_long_bit (parse_gdbarch (par_state))-1)) >> 1) == 0)
+  else if (((result >> (gdbarch_long_bit (par_state->gdbarch ())-1)) >> 1) == 0)
     {
       /* We have a number representable as an unsigned integer quantity.
          For consistency with the C treatment, we will treat it as an
@@ -384,7 +384,7 @@ processInt (struct parser_state *par_state, const char *base0,
          assignment does the trick (no, it doesn't; read the reference manual).
        */
       yylval.typed_val.type
-       = builtin_type (parse_gdbarch (par_state))->builtin_unsigned_long;
+       = builtin_type (par_state->gdbarch ())->builtin_unsigned_long;
       if (result & LONGEST_SIGN)
        yylval.typed_val.val =
          (LONGEST) (result & ~LONGEST_SIGN)

diff --git a/gdb/c-exp.y b/gdb/c-exp.y
index 22768473a83d9b47089f7e6aa4d2f77fb053aeba..b78851972d16c8807e9eb096f996b9532dcf30df 100644 (file)
--- a/gdb/c-exp.y
+++ b/gdb/c-exp.y
@@ -54,7 +54,7 @@
 #include "typeprint.h"
 #include "cp-abi.h"
 
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
    etc).  */
@@ -470,7 +470,7 @@ exp :       OBJC_LBRAC TYPENAME
                        {
                          CORE_ADDR theclass;
 
-                         theclass = lookup_objc_class (parse_gdbarch (pstate),
+                         theclass = lookup_objc_class (pstate->gdbarch (),
                                                     copy_name ($2.stoken));
                          if (theclass == 0)
                            error (_("%s is not an ObjC Class"),
@@ -816,7 +816,7 @@ exp :       SIZEOF '(' type ')'     %prec UNARY
                          write_exp_elt_opcode (pstate, OP_LONG);
                          write_exp_elt_type (pstate, lookup_signed_typename
                                              (parse_language (pstate),
-                                              parse_gdbarch (pstate),
+                                              pstate->gdbarch (),
                                               "int"));
                          type = check_typedef (type);
 
@@ -1285,117 +1285,117 @@ typebase
                        { $$ = $1.type; }
        |       INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "int"); }
        |       LONG
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long"); }
        |       SHORT
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "short"); }
        |       LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long"); }
        |       LONG SIGNED_KEYWORD INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long"); }
        |       LONG SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long"); }
        |       SIGNED_KEYWORD LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long"); }
        |       UNSIGNED LONG INT_KEYWORD
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "long"); }
        |       LONG UNSIGNED INT_KEYWORD
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "long"); }
        |       LONG UNSIGNED
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "long"); }
        |       LONG LONG
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       LONG LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       LONG LONG SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       SIGNED_KEYWORD LONG LONG INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "long long"); }
        |       UNSIGNED LONG LONG
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       UNSIGNED LONG LONG INT_KEYWORD
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       LONG LONG UNSIGNED
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       LONG LONG UNSIGNED INT_KEYWORD
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "long long"); }
        |       SHORT INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "short"); }
        |       SHORT SIGNED_KEYWORD INT_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "short"); }
        |       SHORT SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "short"); }
        |       UNSIGNED SHORT INT_KEYWORD
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "short"); }
        |       SHORT UNSIGNED
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "short"); }
        |       SHORT UNSIGNED INT_KEYWORD
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "short"); }
        |       DOUBLE_KEYWORD
                        { $$ = lookup_typename (parse_language (pstate),
-                                               parse_gdbarch (pstate),
+                                               pstate->gdbarch (),
                                                "double",
                                                NULL,
                                                0); }
        |       LONG DOUBLE_KEYWORD
                        { $$ = lookup_typename (parse_language (pstate),
-                                               parse_gdbarch (pstate),
+                                               pstate->gdbarch (),
                                                "long double",
                                                NULL,
                                                0); }
@@ -1457,19 +1457,19 @@ typebase
                        }
        |       UNSIGNED type_name
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         TYPE_NAME($2.type)); }
        |       UNSIGNED
                        { $$ = lookup_unsigned_typename (parse_language (pstate),
-                                                        parse_gdbarch (pstate),
+                                                        pstate->gdbarch (),
                                                         "int"); }
        |       SIGNED_KEYWORD type_name
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       TYPE_NAME($2.type)); }
        |       SIGNED_KEYWORD
                        { $$ = lookup_signed_typename (parse_language (pstate),
-                                                      parse_gdbarch (pstate),
+                                                      pstate->gdbarch (),
                                                       "int"); }
                 /* It appears that this rule for templates is never
                    reduced; template recognition happens by lookahead
@@ -1490,7 +1490,7 @@ type_name:        TYPENAME
                  $$.stoken.ptr = "int";
                  $$.stoken.length = 3;
                  $$.type = lookup_signed_typename (parse_language (pstate),
-                                                   parse_gdbarch (pstate),
+                                                   pstate->gdbarch (),
                                                    "int");
                }
        |       LONG
@@ -1498,7 +1498,7 @@ type_name:        TYPENAME
                  $$.stoken.ptr = "long";
                  $$.stoken.length = 4;
                  $$.type = lookup_signed_typename (parse_language (pstate),
-                                                   parse_gdbarch (pstate),
+                                                   pstate->gdbarch (),
                                                    "long");
                }
        |       SHORT
@@ -1506,7 +1506,7 @@ type_name:        TYPENAME
                  $$.stoken.ptr = "short";
                  $$.stoken.length = 5;
                  $$.type = lookup_signed_typename (parse_language (pstate),
-                                                   parse_gdbarch (pstate),
+                                                   pstate->gdbarch (),
                                                    "short");
                }
        ;
@@ -2021,10 +2021,10 @@ parse_number (struct parser_state *par_state,
 
   un = n >> 2;
   if (long_p == 0
-      && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
+      && (un >> (gdbarch_int_bit (par_state->gdbarch ()) - 2)) == 0)
     {
       high_bit
-       = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
+       = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);
 
       /* A large decimal (not hex or octal) constant (between INT_MAX
         and UINT_MAX) is a long or unsigned long, according to ANSI,
@@ -2036,10 +2036,10 @@ parse_number (struct parser_state *par_state,
       signed_type = parse_type (par_state)->builtin_int;
     }
   else if (long_p <= 1
-          && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
+          && (un >> (gdbarch_long_bit (par_state->gdbarch ()) - 2)) == 0)
     {
       high_bit
-       = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
+       = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 1);
       unsigned_type = parse_type (par_state)->builtin_unsigned_long;
       signed_type = parse_type (par_state)->builtin_long;
     }
@@ -2047,11 +2047,11 @@ parse_number (struct parser_state *par_state,
     {
       int shift;
       if (sizeof (ULONGEST) * HOST_CHAR_BIT
-         < gdbarch_long_long_bit (parse_gdbarch (par_state)))
+         < gdbarch_long_long_bit (par_state->gdbarch ()))
        /* A long long does not fit in a LONGEST.  */
        shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
       else
-       shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
+       shift = (gdbarch_long_long_bit (par_state->gdbarch ()) - 1);
       high_bit = (ULONGEST) 1 << shift;
       unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
       signed_type = parse_type (par_state)->builtin_long_long;
@@ -3001,7 +3001,7 @@ classify_name (struct parser_state *par_state, const struct block *block,
   /* See if it's an ObjC classname.  */
   if (parse_language (par_state)->la_language == language_objc && !bsym.symbol)
     {
-      CORE_ADDR Class = lookup_objc_class (parse_gdbarch (par_state), copy);
+      CORE_ADDR Class = lookup_objc_class (par_state->gdbarch (), copy);
       if (Class)
        {
          struct symbol *sym;

diff --git a/gdb/d-exp.y b/gdb/d-exp.y
index a0f7b958c3f9d096599a14a7a015de14826075f0..73d5cfc368ad8e63a719fefc6ee00c771a1c5e79 100644 (file)
--- a/gdb/d-exp.y
+++ b/gdb/d-exp.y
@@ -52,8 +52,8 @@
 #include "charset.h"
 #include "block.h"
 
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
-#define parse_d_type(ps) builtin_d_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
+#define parse_d_type(ps) builtin_d_type (ps->gdbarch ())
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
    etc).  */
@@ -1289,7 +1289,7 @@ lex_one_token (struct parser_state *par_state)
 
   yylval.tsym.type
     = language_lookup_primitive_type (parse_language (par_state),
-                                     parse_gdbarch (par_state), copy);
+                                     par_state->gdbarch (), copy);
   if (yylval.tsym.type != NULL)
     return TYPENAME;
 

diff --git a/gdb/f-exp.y b/gdb/f-exp.y
index f99c26d326e47dc97777445c0992b1de8c59f2df..499de419222241ba013662e74564ac8927eb75ed 100644 (file)
--- a/gdb/f-exp.y
+++ b/gdb/f-exp.y
@@ -55,8 +55,8 @@
 #include <ctype.h>
 #include <algorithm>
 
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
-#define parse_f_type(ps) builtin_f_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
+#define parse_f_type(ps) builtin_f_type (ps->gdbarch ())
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
    etc).  */
@@ -763,22 +763,22 @@ parse_number (struct parser_state *par_state,
      are the same size.  So we shift it twice, with fewer bits
      each time, for the same result.  */
   
-  if ((gdbarch_int_bit (parse_gdbarch (par_state))
-       != gdbarch_long_bit (parse_gdbarch (par_state))
+  if ((gdbarch_int_bit (par_state->gdbarch ())
+       != gdbarch_long_bit (par_state->gdbarch ())
        && ((n >> 2)
-          >> (gdbarch_int_bit (parse_gdbarch (par_state))-2))) /* Avoid
+          >> (gdbarch_int_bit (par_state->gdbarch ())-2))) /* Avoid
                                                            shift warning */
       || long_p)
     {
       high_bit = ((ULONGEST)1)
-      << (gdbarch_long_bit (parse_gdbarch (par_state))-1);
+      << (gdbarch_long_bit (par_state->gdbarch ())-1);
       unsigned_type = parse_type (par_state)->builtin_unsigned_long;
       signed_type = parse_type (par_state)->builtin_long;
     }
   else 
     {
       high_bit =
-       ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
+       ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);
       unsigned_type = parse_type (par_state)->builtin_unsigned_int;
       signed_type = parse_type (par_state)->builtin_int;
     }    
@@ -1291,7 +1291,7 @@ yylex (void)
 
     yylval.tsym.type
       = language_lookup_primitive_type (parse_language (pstate),
-                                       parse_gdbarch (pstate), tmp);
+                                       pstate->gdbarch (), tmp);
     if (yylval.tsym.type != NULL)
       return TYPENAME;
     

diff --git a/gdb/go-exp.y b/gdb/go-exp.y
index 44af2a6fd07f63dafe1052a5898917408d3116d2..35f480abe814baacdf4791e9cd9213bf57721a8a 100644 (file)
--- a/gdb/go-exp.y
+++ b/gdb/go-exp.y
@@ -65,7 +65,7 @@
 #include "charset.h"
 #include "block.h"
 
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
    etc).  */
@@ -603,7 +603,7 @@ type  /* Implements (approximately): [*] type-specifier */
                                              expression_context_block); }
 */
        |       BYTE_KEYWORD
-                       { $$ = builtin_go_type (parse_gdbarch (pstate))
+                       { $$ = builtin_go_type (pstate->gdbarch ())
                            ->builtin_uint8; }
        ;
 
@@ -664,7 +664,7 @@ parse_number (struct parser_state *par_state,
   if (parsed_float)
     {
       const struct builtin_go_type *builtin_go_types
-       = builtin_go_type (parse_gdbarch (par_state));
+       = builtin_go_type (par_state->gdbarch ());
 
       /* Handle suffixes: 'f' for float32, 'l' for long double.
         FIXME: This appears to be an extension -- do we want this?  */
@@ -803,10 +803,10 @@ parse_number (struct parser_state *par_state,
 
   un = (ULONGEST)n >> 2;
   if (long_p == 0
-      && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
+      && (un >> (gdbarch_int_bit (par_state->gdbarch ()) - 2)) == 0)
     {
       high_bit
-        = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
+        = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);
 
       /* A large decimal (not hex or octal) constant (between INT_MAX
         and UINT_MAX) is a long or unsigned long, according to ANSI,
@@ -818,10 +818,10 @@ parse_number (struct parser_state *par_state,
       signed_type = parse_type (par_state)->builtin_int;
     }
   else if (long_p <= 1
-          && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
+          && (un >> (gdbarch_long_bit (par_state->gdbarch ()) - 2)) == 0)
     {
       high_bit
-       = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
+       = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 1);
       unsigned_type = parse_type (par_state)->builtin_unsigned_long;
       signed_type = parse_type (par_state)->builtin_long;
     }
@@ -829,11 +829,11 @@ parse_number (struct parser_state *par_state,
     {
       int shift;
       if (sizeof (ULONGEST) * HOST_CHAR_BIT
-         < gdbarch_long_long_bit (parse_gdbarch (par_state)))
+         < gdbarch_long_long_bit (par_state->gdbarch ()))
        /* A long long does not fit in a LONGEST.  */
        shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
       else
-       shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
+       shift = (gdbarch_long_long_bit (par_state->gdbarch ()) - 1);
       high_bit = (ULONGEST) 1 << shift;
       unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
       signed_type = parse_type (par_state)->builtin_long_long;
@@ -1401,7 +1401,7 @@ classify_name (struct parser_state *par_state, const struct block *block)
 
   /* Try primitive types first so they win over bad/weird debug info.  */
   type = language_lookup_primitive_type (parse_language (par_state),
-                                        parse_gdbarch (par_state),
+                                        par_state->gdbarch (),
                                         copy);
   if (type != NULL)
     {

diff --git a/gdb/m2-exp.y b/gdb/m2-exp.y
index 85d587651a28ba18e976fd71decb068ff01f4a5e..c78e03fab95e2be407b5d198461a9b3e8ca0360c 100644 (file)
--- a/gdb/m2-exp.y
+++ b/gdb/m2-exp.y
@@ -48,8 +48,8 @@
 #include "objfiles.h" /* For have_full_symbols and have_partial_symbols */
 #include "block.h"
 
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
-#define parse_m2_type(ps) builtin_m2_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
+#define parse_m2_type(ps) builtin_m2_type (ps->gdbarch ())
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
    etc).  */
@@ -597,7 +597,7 @@ variable:   NAME
 type
        :       TYPENAME
                        { $$ = lookup_typename (parse_language (pstate),
-                                               parse_gdbarch (pstate),
+                                               pstate->gdbarch (),
                                                copy_name ($1),
                                                expression_context_block, 0); }
 
@@ -968,7 +968,7 @@ yylex (void)
     sym = lookup_symbol (tmp, expression_context_block, VAR_DOMAIN, 0).symbol;
     if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
       return BLOCKNAME;
-    if (lookup_typename (parse_language (pstate), parse_gdbarch (pstate),
+    if (lookup_typename (parse_language (pstate), pstate->gdbarch (),
                         copy_name (yylval.sval),
                         expression_context_block, 1))
       return TYPENAME;

diff --git a/gdb/objc-lang.c b/gdb/objc-lang.c
index ceef482ae35a3f426c0986675d15c11c4d7542d3..83d2c056d6a9d7c2e1db44062524d8995abc9b23 100644 (file)
--- a/gdb/objc-lang.c
+++ b/gdb/objc-lang.c
@@ -491,7 +491,7 @@ end_msglist (struct parser_state *ps)
   selname_chain = sel->next;
   msglist_len = sel->msglist_len;
   msglist_sel = sel->msglist_sel;
-  selid = lookup_child_selector (parse_gdbarch (ps), p);
+  selid = lookup_child_selector (ps->gdbarch (), p);
   if (!selid)
     error (_("Can't find selector \"%s\""), p);
   write_exp_elt_longcst (ps, selid);

diff --git a/gdb/p-exp.y b/gdb/p-exp.y
index 31e8c4bea665acf3ce50f44e88ffcbf35267ee45..d4b315061b03105e7f550a8208ad9a8d65e6d5e3 100644 (file)
--- a/gdb/p-exp.y
+++ b/gdb/p-exp.y
@@ -56,7 +56,7 @@
 #include "block.h"
 #include "completer.h"
 
-#define parse_type(ps) builtin_type (parse_gdbarch (ps))
+#define parse_type(ps) builtin_type (ps->gdbarch ())
 
 /* Remap normal yacc parser interface names (yyparse, yylex, yyerror,
    etc).  */
@@ -528,7 +528,7 @@ exp :       DOLLAR_VARIABLE
                             struct value * val, * mark;
 
                             mark = value_mark ();
-                            val = value_of_internalvar (parse_gdbarch (pstate),
+                            val = value_of_internalvar (pstate->gdbarch (),
                                                         intvar);
                             current_type = value_type (val);
                             value_release_to_mark (mark);
@@ -973,10 +973,10 @@ parse_number (struct parser_state *par_state,
 
   un = (ULONGEST)n >> 2;
   if (long_p == 0
-      && (un >> (gdbarch_int_bit (parse_gdbarch (par_state)) - 2)) == 0)
+      && (un >> (gdbarch_int_bit (par_state->gdbarch ()) - 2)) == 0)
     {
       high_bit
-       = ((ULONGEST)1) << (gdbarch_int_bit (parse_gdbarch (par_state)) - 1);
+       = ((ULONGEST)1) << (gdbarch_int_bit (par_state->gdbarch ()) - 1);
 
       /* A large decimal (not hex or octal) constant (between INT_MAX
         and UINT_MAX) is a long or unsigned long, according to ANSI,
@@ -988,10 +988,10 @@ parse_number (struct parser_state *par_state,
       signed_type = parse_type (par_state)->builtin_int;
     }
   else if (long_p <= 1
-          && (un >> (gdbarch_long_bit (parse_gdbarch (par_state)) - 2)) == 0)
+          && (un >> (gdbarch_long_bit (par_state->gdbarch ()) - 2)) == 0)
     {
       high_bit
-       = ((ULONGEST)1) << (gdbarch_long_bit (parse_gdbarch (par_state)) - 1);
+       = ((ULONGEST)1) << (gdbarch_long_bit (par_state->gdbarch ()) - 1);
       unsigned_type = parse_type (par_state)->builtin_unsigned_long;
       signed_type = parse_type (par_state)->builtin_long;
     }
@@ -999,11 +999,11 @@ parse_number (struct parser_state *par_state,
     {
       int shift;
       if (sizeof (ULONGEST) * HOST_CHAR_BIT
-         < gdbarch_long_long_bit (parse_gdbarch (par_state)))
+         < gdbarch_long_long_bit (par_state->gdbarch ()))
        /* A long long does not fit in a LONGEST.  */
        shift = (sizeof (ULONGEST) * HOST_CHAR_BIT - 1);
       else
-       shift = (gdbarch_long_long_bit (parse_gdbarch (par_state)) - 1);
+       shift = (gdbarch_long_long_bit (par_state->gdbarch ()) - 1);
       high_bit = (ULONGEST) 1 << shift;
       unsigned_type = parse_type (par_state)->builtin_unsigned_long_long;
       signed_type = parse_type (par_state)->builtin_long_long;
@@ -1173,7 +1173,7 @@ yylex (void)
       lexptr++;
       c = *lexptr++;
       if (c == '\\')
-       c = parse_escape (parse_gdbarch (pstate), &lexptr);
+       c = parse_escape (pstate->gdbarch (), &lexptr);
       else if (c == '\'')
        error (_("Empty character constant."));
 
@@ -1343,7 +1343,7 @@ yylex (void)
            break;
          case '\\':
            ++tokptr;
-           c = parse_escape (parse_gdbarch (pstate), &tokptr);
+           c = parse_escape (pstate->gdbarch (), &tokptr);
            if (c == -1)
              {
                continue;
@@ -1676,7 +1676,7 @@ yylex (void)
         }
     yylval.tsym.type
       = language_lookup_primitive_type (parse_language (pstate),
-                                       parse_gdbarch (pstate), tmp);
+                                       pstate->gdbarch (), tmp);
     if (yylval.tsym.type != NULL)
       {
        free (uptokstart);

diff --git a/gdb/parse.c b/gdb/parse.c
index 69c63da787f966d9699b31898bb1233b662d357f..e2d01e9dd9771f51e5b71774924a6fa94d26d5d2 100644 (file)
--- a/gdb/parse.c
+++ b/gdb/parse.c
@@ -631,7 +631,7 @@ write_dollar_variable (struct parser_state *ps, struct stoken str)
 
   /* Handle tokens that refer to machine registers:
      $ followed by a register name.  */
-  i = user_reg_map_name_to_regnum (parse_gdbarch (ps),
+  i = user_reg_map_name_to_regnum (ps->gdbarch (),
                                   str.ptr + 1, str.length - 1);
   if (i >= 0)
     goto handle_register;
@@ -1420,7 +1420,7 @@ insert_type_address_space (struct parser_state *pstate, char *string)
 
   element.piece = tp_space_identifier;
   insert_into_type_stack (slot, element);
-  element.int_val = address_space_name_to_int (parse_gdbarch (pstate),
+  element.int_val = address_space_name_to_int (pstate->gdbarch (),
                                               string);
   insert_into_type_stack (slot, element);
 }

diff --git a/gdb/parser-defs.h b/gdb/parser-defs.h
index ffdbd836a192472511f289680ecce95d31180081..1aa5f1ff2e37bca79402dae164a8134944904421 100644 (file)
--- a/gdb/parser-defs.h
+++ b/gdb/parser-defs.h
@@ -32,7 +32,6 @@ struct internalvar;
 
 extern int parser_debug;
 
-#define parse_gdbarch(ps) ((ps)->expout->gdbarch)
 #define parse_language(ps) ((ps)->expout->language_defn)
 
 struct parser_state
@@ -49,6 +48,13 @@ struct parser_state
      it as an expression_up -- passing ownership to the caller.  */
   ATTRIBUTE_UNUSED_RESULT expression_up release ();
 
+  /* Return the gdbarch that was passed to the constructor.  */
+
+  struct gdbarch *gdbarch ()
+  {
+    return expout->gdbarch;
+  }
+
   /* The size of the expression above.  */
 
   size_t expout_size;

diff --git a/gdb/rust-exp.y b/gdb/rust-exp.y
index 1379030730c1da47b005b78733e567498f6f2bb2..60eb6172f0365f4807f2e7acc8d1469e97706382 100644 (file)
--- a/gdb/rust-exp.y
+++ b/gdb/rust-exp.y
@@ -211,7 +211,7 @@ struct rust_parser
   /* Return the parser's gdbarch.  */
   struct gdbarch *arch () const
   {
-    return parse_gdbarch (pstate);
+    return pstate->gdbarch ();
   }
 
   /* A helper to look up a Rust type, or fail.  This only works for
@@ -2281,7 +2281,7 @@ rust_parser::convert_ast_to_expression (const struct rust_op *operation,
          struct type *type;
 
          type = language_lookup_primitive_type (parse_language (pstate),
-                                                parse_gdbarch (pstate),
+                                                pstate->gdbarch (),
                                                 "()");
 
          write_exp_elt_opcode (pstate, OP_LONG);