From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 120874 invoked by alias); 11 Sep 2017 12:58:01 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Received: (qmail 120623 invoked by uid 89); 11 Sep 2017 12:58:00 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.6 required=5.0 tests=AWL,BAYES_00,GIT_PATCH_0,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_LAZY_DOMAIN_SECURITY,RP_MATCHES_RCVD autolearn=ham version=3.3.2 spammy= X-HELO: mga04.intel.com Received: from mga04.intel.com (HELO mga04.intel.com) (192.55.52.120) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 11 Sep 2017 12:57:58 +0000 Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga104.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 11 Sep 2017 05:57:56 -0700 X-ExtLoop1: 1 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga006.fm.intel.com with ESMTP; 11 Sep 2017 05:57:55 -0700 Received: from ulvlx001.iul.intel.com (ulvlx001.iul.intel.com [172.28.207.17]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id v8BCvsQT016537; Mon, 11 Sep 2017 13:57:54 +0100 Received: from ulvlx001.iul.intel.com (localhost [127.0.0.1]) by ulvlx001.iul.intel.com with ESMTP id v8BCvsSc029667; Mon, 11 Sep 2017 14:57:54 +0200 Received: (from twiederh@localhost) by ulvlx001.iul.intel.com with LOCAL id v8BCvsaq029663; Mon, 11 Sep 2017 14:57:54 +0200 From: Tim Wiederhake To: gdb-patches@sourceware.org Cc: Christoph Weinmann Subject: [PATCH 4/5] Fortran: Change subrange enum to bit field. Date: Mon, 11 Sep 2017 12:58:00 -0000 Message-Id: <1505134663-29374-5-git-send-email-tim.wiederhake@intel.com> In-Reply-To: <1505134663-29374-1-git-send-email-tim.wiederhake@intel.com> References: <1505134663-29374-1-git-send-email-tim.wiederhake@intel.com> X-IsSubscribed: yes X-SW-Source: 2017-09/txt/msg00303.txt.bz2 From: Christoph Weinmann Change Fortran subrange enum for subrange expressions to represent a bitfield for easier manipulation. Consequently also change occurences and evaluation of said enum. The behaviour of GDB is unchanged. xxxx-yy-zz Christoph Weinmann Tim Wiederhake * expprint.c (print_subexp_standard): Use bitfield instead of enum. (dump_subexp_body_standard): Same. * f-exp.y (subrange): Same. * f-lang.c (f90_value_subarray): Same. * parse.c (operator_length_standard): Same. * rust-exp.y: Same. * rust-lang.c (rust_range, rust_compute_range, rust_subscript): Same. * expression.h (enum range_type): Turn into a bitfield. --- gdb/expprint.c | 20 ++++++++------------ gdb/expression.h | 15 ++++++--------- gdb/f-exp.y | 11 ++++++----- gdb/f-lang.c | 8 ++++---- gdb/parse.c | 21 ++++++++------------- gdb/rust-exp.y | 12 +++--------- gdb/rust-lang.c | 17 ++++++++--------- 7 files changed, 43 insertions(+), 61 deletions(-) diff --git a/gdb/expprint.c b/gdb/expprint.c index 9e04f24..19d1c88 100644 --- a/gdb/expprint.c +++ b/gdb/expprint.c @@ -581,12 +581,10 @@ print_subexp_standard (struct expression *exp, int *pos, *pos += 2; fputs_filtered ("RANGE(", stream); - if (range_type == HIGH_BOUND_DEFAULT - || range_type == NONE_BOUND_DEFAULT) + if ((range_type & SUBARRAY_LOW_BOUND) != 0) print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); fputs_filtered ("..", stream); - if (range_type == LOW_BOUND_DEFAULT - || range_type == NONE_BOUND_DEFAULT) + if ((range_type & SUBARRAY_HIGH_BOUND) != 0) print_subexp (exp, pos, stream, PREC_ABOVE_COMMA); fputs_filtered (")", stream); return; @@ -1093,16 +1091,16 @@ dump_subexp_body_standard (struct expression *exp, switch (range_type) { - case BOTH_BOUND_DEFAULT: + case SUBARRAY_NO_BOUND: fputs_filtered ("Range '..'", stream); break; - case LOW_BOUND_DEFAULT: + case SUBARRAY_HIGH_BOUND: fputs_filtered ("Range '..EXP'", stream); break; - case HIGH_BOUND_DEFAULT: + case SUBARRAY_LOW_BOUND: fputs_filtered ("Range 'EXP..'", stream); break; - case NONE_BOUND_DEFAULT: + case (SUBARRAY_LOW_BOUND | SUBARRAY_HIGH_BOUND): fputs_filtered ("Range 'EXP..EXP'", stream); break; default: @@ -1110,11 +1108,9 @@ dump_subexp_body_standard (struct expression *exp, break; } - if (range_type == HIGH_BOUND_DEFAULT - || range_type == NONE_BOUND_DEFAULT) + if ((range_type & SUBARRAY_LOW_BOUND) != 0) elt = dump_subexp (exp, stream, elt); - if (range_type == LOW_BOUND_DEFAULT - || range_type == NONE_BOUND_DEFAULT) + if ((range_type & SUBARRAY_HIGH_BOUND) != 0) elt = dump_subexp (exp, stream, elt); } break; diff --git a/gdb/expression.h b/gdb/expression.h index 9e4ddf5..c794198 100644 --- a/gdb/expression.h +++ b/gdb/expression.h @@ -155,17 +155,14 @@ extern void dump_raw_expression (struct expression *, struct ui_file *, const char *); extern void dump_prefix_expression (struct expression *, struct ui_file *); -/* In an OP_RANGE expression, either bound could be empty, indicating - that its value is by default that of the corresponding bound of the - array or string. So we have four sorts of subrange. This - enumeration type is to identify this. */ - +/* Flags to indicate which boundarys are set in an OP_RANGE expression. Values + can be or'ed together. */ + enum range_type { - BOTH_BOUND_DEFAULT, /* "(:)" */ - LOW_BOUND_DEFAULT, /* "(:high)" */ - HIGH_BOUND_DEFAULT, /* "(low:)" */ - NONE_BOUND_DEFAULT /* "(low:high)" */ + SUBARRAY_NO_BOUND = 0x0, /* "( : )" */ + SUBARRAY_LOW_BOUND = 0x1, /* "(low:)" */ + SUBARRAY_HIGH_BOUND = 0x2 /* "(:high)" */ }; #endif /* !defined (EXPRESSION_H) */ diff --git a/gdb/f-exp.y b/gdb/f-exp.y index bfa9d09..96b9b05 100644 --- a/gdb/f-exp.y +++ b/gdb/f-exp.y @@ -261,26 +261,27 @@ arglist : arglist ',' exp %prec ABOVE_COMMA /* There are four sorts of subrange types in F90. */ subrange: exp ':' exp %prec ABOVE_COMMA - { write_exp_elt_opcode (pstate, OP_RANGE); - write_exp_elt_longcst (pstate, NONE_BOUND_DEFAULT); + { write_exp_elt_opcode (pstate, OP_RANGE); + write_exp_elt_longcst (pstate, + SUBARRAY_LOW_BOUND | SUBARRAY_HIGH_BOUND); write_exp_elt_opcode (pstate, OP_RANGE); } ; subrange: exp ':' %prec ABOVE_COMMA { write_exp_elt_opcode (pstate, OP_RANGE); - write_exp_elt_longcst (pstate, HIGH_BOUND_DEFAULT); + write_exp_elt_longcst (pstate, SUBARRAY_LOW_BOUND); write_exp_elt_opcode (pstate, OP_RANGE); } ; subrange: ':' exp %prec ABOVE_COMMA { write_exp_elt_opcode (pstate, OP_RANGE); - write_exp_elt_longcst (pstate, LOW_BOUND_DEFAULT); + write_exp_elt_longcst (pstate, SUBARRAY_HIGH_BOUND); write_exp_elt_opcode (pstate, OP_RANGE); } ; subrange: ':' %prec ABOVE_COMMA { write_exp_elt_opcode (pstate, OP_RANGE); - write_exp_elt_longcst (pstate, BOTH_BOUND_DEFAULT); + write_exp_elt_longcst (pstate, SUBARRAY_NO_BOUND); write_exp_elt_opcode (pstate, OP_RANGE); } ; diff --git a/gdb/f-lang.c b/gdb/f-lang.c index 25bb758..832a3e7 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -503,9 +503,9 @@ f90_value_subarray (struct value *array, struct expression *exp, int *pos, *pos += 3; - if (type == HIGH_BOUND_DEFAULT || type == NONE_BOUND_DEFAULT) + if ((type & SUBARRAY_LOW_BOUND) != 0) lo = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); - if (type == LOW_BOUND_DEFAULT || type == NONE_BOUND_DEFAULT) + if ((type & SUBARRAY_HIGH_BOUND) != 0) hi = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside)); subscript_array.emplace_back (type, lo, hi); @@ -533,9 +533,9 @@ f90_value_subarray (struct value *array, struct expression *exp, int *pos, if (it->kind == subscript::SUBSCRIPT_RANGE) { - if (it->type == LOW_BOUND_DEFAULT || it->type == BOTH_BOUND_DEFAULT) + if ((it->type & SUBARRAY_LOW_BOUND) == 0) it->low = lo; - if (it->type == HIGH_BOUND_DEFAULT || it->type == BOTH_BOUND_DEFAULT) + if ((it->type & SUBARRAY_HIGH_BOUND) == 0) it->high = hi; if (it->low < lo || it->low > hi || it->high < lo || it->high > hi) diff --git a/gdb/parse.c b/gdb/parse.c index fb0dff2..dcf1b31 100644 --- a/gdb/parse.c +++ b/gdb/parse.c @@ -1001,22 +1001,17 @@ operator_length_standard (const struct expression *expr, int endpos, case OP_RANGE: oplen = 3; + args = 0; range_type = (enum range_type) longest_to_int (expr->elts[endpos - 2].longconst); - switch (range_type) - { - case LOW_BOUND_DEFAULT: - case HIGH_BOUND_DEFAULT: - args = 1; - break; - case BOTH_BOUND_DEFAULT: - args = 0; - break; - case NONE_BOUND_DEFAULT: - args = 2; - break; - } + /* Increment the argument counter for each argument + provided by the user. */ + if ((range_type & SUBARRAY_LOW_BOUND) != 0) + args++; + + if ((range_type & SUBARRAY_HIGH_BOUND) != 0) + args++; break; diff --git a/gdb/rust-exp.y b/gdb/rust-exp.y index 4cb3aa2..9adcae5 100644 --- a/gdb/rust-exp.y +++ b/gdb/rust-exp.y @@ -2460,23 +2460,17 @@ convert_ast_to_expression (struct parser_state *state, case OP_RANGE: { - enum range_type kind = BOTH_BOUND_DEFAULT; + enum range_type kind = SUBARRAY_NO_BOUND; if (operation->left.op != NULL) { convert_ast_to_expression (state, operation->left.op, top); - kind = HIGH_BOUND_DEFAULT; + kind = (range_type) (kind | SUBARRAY_LOW_BOUND); } if (operation->right.op != NULL) { convert_ast_to_expression (state, operation->right.op, top); - if (kind == BOTH_BOUND_DEFAULT) - kind = LOW_BOUND_DEFAULT; - else - { - gdb_assert (kind == HIGH_BOUND_DEFAULT); - kind = NONE_BOUND_DEFAULT; - } + kind = (range_type) (kind | SUBARRAY_HIGH_BOUND); } write_exp_elt_opcode (state, OP_RANGE); write_exp_elt_longcst (state, kind); diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c index c5764bf..45005fd5 100644 --- a/gdb/rust-lang.c +++ b/gdb/rust-lang.c @@ -1311,9 +1311,9 @@ rust_range (struct expression *exp, int *pos, enum noside noside) kind = (enum range_type) longest_to_int (exp->elts[*pos + 1].longconst); *pos += 3; - if (kind == HIGH_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT) + if ((kind & SUBARRAY_LOW_BOUND) != 0) low = evaluate_subexp (NULL_TYPE, exp, pos, noside); - if (kind == LOW_BOUND_DEFAULT || kind == NONE_BOUND_DEFAULT) + if ((kind & SUBARRAY_HIGH_BOUND) != 0) high = evaluate_subexp (NULL_TYPE, exp, pos, noside); if (noside == EVAL_SKIP) @@ -1402,7 +1402,7 @@ rust_compute_range (struct type *type, struct value *range, *low = 0; *high = 0; - *kind = BOTH_BOUND_DEFAULT; + *kind = SUBARRAY_NO_BOUND; if (TYPE_NFIELDS (type) == 0) return; @@ -1410,15 +1410,14 @@ rust_compute_range (struct type *type, struct value *range, i = 0; if (strcmp (TYPE_FIELD_NAME (type, 0), "start") == 0) { - *kind = HIGH_BOUND_DEFAULT; + *kind = SUBARRAY_LOW_BOUND; *low = value_as_long (value_field (range, 0)); ++i; } if (TYPE_NFIELDS (type) > i && strcmp (TYPE_FIELD_NAME (type, i), "end") == 0) { - *kind = (*kind == BOTH_BOUND_DEFAULT - ? LOW_BOUND_DEFAULT : NONE_BOUND_DEFAULT); + *kind = (range_type) (*kind | SUBARRAY_HIGH_BOUND); *high = value_as_long (value_field (range, i)); } } @@ -1433,7 +1432,7 @@ rust_subscript (struct expression *exp, int *pos, enum noside noside, struct type *rhstype; LONGEST low, high_bound; /* Initialized to appease the compiler. */ - enum range_type kind = BOTH_BOUND_DEFAULT; + enum range_type kind = SUBARRAY_NO_BOUND; LONGEST high = 0; int want_slice = 0; @@ -1495,7 +1494,7 @@ rust_subscript (struct expression *exp, int *pos, enum noside noside, error (_("Cannot subscript non-array type")); if (want_slice - && (kind == BOTH_BOUND_DEFAULT || kind == LOW_BOUND_DEFAULT)) + && ((kind & SUBARRAY_LOW_BOUND) == 0)) low = low_bound; if (low < 0) error (_("Index less than zero")); @@ -1513,7 +1512,7 @@ rust_subscript (struct expression *exp, int *pos, enum noside noside, CORE_ADDR addr; struct value *addrval, *tem; - if (kind == BOTH_BOUND_DEFAULT || kind == HIGH_BOUND_DEFAULT) + if ((kind & SUBARRAY_HIGH_BOUND) == 0) high = high_bound; if (high < 0) error (_("High index less than zero")); -- 2.7.4