From patchwork Wed Apr 3 01:37:55 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tom Tromey X-Patchwork-Id: 32137 Received: (qmail 27103 invoked by alias); 3 Apr 2019 01:38:14 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 27024 invoked by uid 89); 3 Apr 2019 01:38:13 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-15.9 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS autolearn=ham version=3.3.1 spammy=recognition, ANSI, approximately, ansi X-HELO: gateway20.websitewelcome.com Received: from gateway20.websitewelcome.com (HELO gateway20.websitewelcome.com) (192.185.54.2) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 03 Apr 2019 01:38:09 +0000 Received: from cm16.websitewelcome.com (cm16.websitewelcome.com [100.42.49.19]) by gateway20.websitewelcome.com (Postfix) with ESMTP id 010FE400C7B5D for ; Tue, 2 Apr 2019 20:38:08 -0500 (CDT) Received: from box5379.bluehost.com ([162.241.216.53]) by cmsmtp with SMTP id BUqthXbyC4FKpBUqth3WLN; Tue, 02 Apr 2019 20:38:07 -0500 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=tromey.com; s=default; h=References:In-Reply-To:Message-Id:Date:Subject:Cc:To:From: Sender:Reply-To:MIME-Version:Content-Type:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:List-Id:List-Help:List-Unsubscribe: List-Subscribe:List-Post:List-Owner:List-Archive; bh=NyGrzdvP/TXTWPBiEBVXaxpkHUc43VsfY5MlvSFb5yw=; b=ghEOLDtFLxVD7Te2LVYzqzeqih NIPyyl6lJUpq/dfr7l+FaMWeq/ZI55pRxNX7sM17OgxZ4fpPEOSRSQphRW33jjnz4dBYAFFgGxYxP ST/3qgNx/hoNEF70dUV5z7Uye; Received: from 174-29-37-56.hlrn.qwest.net ([174.29.37.56]:34720 helo=bapiya.Home) by box5379.bluehost.com with esmtpsa (TLSv1.2:ECDHE-RSA-AES256-GCM-SHA384:256) (Exim 4.91) (envelope-from ) id 1hBUqt-002Gj6-Ms; Tue, 02 Apr 2019 20:38:07 -0500 From: Tom Tromey To: gdb-patches@sourceware.org Cc: Tom Tromey Subject: [PATCH 03/13] Turn parse_gdbarch into a method Date: Tue, 2 Apr 2019 19:37:55 -0600 Message-Id: <20190403013805.11978-4-tom@tromey.com> In-Reply-To: <20190403013805.11978-1-tom@tromey.com> References: <20190403013805.11978-1-tom@tromey.com> This changes parse_gdbarch into a method of parser_state. This patch was written by a script. gdb/ChangeLog 2019-04-02 Tom Tromey * 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. --- gdb/ChangeLog | 23 ++++++++++++ gdb/ada-exp.y | 8 ++--- gdb/ada-lex.l | 8 ++--- gdb/c-exp.y | 90 +++++++++++++++++++++++------------------------ gdb/d-exp.y | 6 ++-- gdb/f-exp.y | 16 ++++----- gdb/go-exp.y | 20 +++++------ gdb/m2-exp.y | 8 ++--- gdb/objc-lang.c | 2 +- gdb/p-exp.y | 22 ++++++------ gdb/parse.c | 4 +-- gdb/parser-defs.h | 8 ++++- gdb/rust-exp.y | 4 +-- 13 files changed, 124 insertions(+), 95 deletions(-) diff --git a/gdb/ada-exp.y b/gdb/ada-exp.y index 5925416e88f..74dab760cf8 100644 --- 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 05af013c258..17ac7e5d3d5 100644 --- 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 22768473a83..b78851972d1 100644 --- 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 a0f7b958c3f..73d5cfc368a 100644 --- 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 f99c26d326e..499de419222 100644 --- a/gdb/f-exp.y +++ b/gdb/f-exp.y @@ -55,8 +55,8 @@ #include #include -#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 44af2a6fd07..35f480abe81 100644 --- 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 85d587651a2..c78e03fab95 100644 --- 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 ceef482ae35..83d2c056d6a 100644 --- 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 31e8c4bea66..d4b315061b0 100644 --- 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 69c63da787f..e2d01e9dd97 100644 --- 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 ffdbd836a19..1aa5f1ff2e3 100644 --- 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 1379030730c..60eb6172f03 100644 --- 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);