From 1f8d2881175920d389078852bb1ff0799d744599 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Wed, 9 Dec 2020 13:51:57 -0500 Subject: [PATCH] gdb: make get_discrete_bounds return bool get_discrete_bounds currently has three possible return values (see its current doc for details). It appears that for all callers, it would be sufficient to have a boolean "worked" / "didn't work" return value. Change the return type of get_discrete_bounds to bool and adjust all callers. Doing so simplifies the following patch. gdb/ChangeLog: * gdbtypes.h (get_discrete_bounds): Return bool, adjust all callers. * gdbtypes.c (get_discrete_bounds): Return bool. Change-Id: Ie51feee23c75f0cd7939742604282d745db59172 --- gdb/ChangeLog | 6 +++++ gdb/ada-lang.c | 6 ++--- gdb/ada-valprint.c | 2 +- gdb/c-lang.c | 4 ++-- gdb/eval.c | 4 ++-- gdb/f-array-walker.h | 4 ++-- gdb/f-lang.c | 2 +- gdb/gdbtypes.c | 53 ++++++++++++++++++++------------------------ gdb/gdbtypes.h | 8 ++++++- gdb/m2-typeprint.c | 4 ++-- gdb/m2-valprint.c | 6 ++--- gdb/p-valprint.c | 3 ++- gdb/valarith.c | 2 +- gdb/valops.c | 4 ++-- 14 files changed, 58 insertions(+), 50 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 468bbca3d02..e7f083ca58f 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,9 @@ +2020-12-09 Simon Marchi + + * gdbtypes.h (get_discrete_bounds): Return bool, adjust all + callers. + * gdbtypes.c (get_discrete_bounds): Return bool. + 2020-12-09 Simon Marchi * ada-lang.c (ada_value_slice_from_ptr): Adjust. diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 5813ecded44..5e2f1ece965 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -2112,7 +2112,7 @@ constrained_packed_array_type (struct type *type, long *elt_bits) if ((check_typedef (index_type)->code () == TYPE_CODE_RANGE && is_dynamic_type (check_typedef (index_type))) - || get_discrete_bounds (index_type, &low_bound, &high_bound) < 0) + || !get_discrete_bounds (index_type, &low_bound, &high_bound)) low_bound = high_bound = 0; if (high_bound < low_bound) *elt_bits = TYPE_LENGTH (new_type) = 0; @@ -2182,7 +2182,7 @@ recursively_update_array_bitsize (struct type *type) gdb_assert (type->code () == TYPE_CODE_ARRAY); LONGEST low, high; - if (get_discrete_bounds (type->index_type (), &low, &high) < 0 + if (!get_discrete_bounds (type->index_type (), &low, &high) || low > high) return 0; LONGEST our_len = high - low + 1; @@ -2299,7 +2299,7 @@ value_subscript_packed (struct value *arr, int arity, struct value **ind) LONGEST lowerbound, upperbound; LONGEST idx; - if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0) + if (!get_discrete_bounds (range_type, &lowerbound, &upperbound)) { lim_warning (_("don't know bounds of array")); lowerbound = upperbound = 0; diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c index 6ddb584d11c..7d17f410c92 100644 --- a/gdb/ada-valprint.c +++ b/gdb/ada-valprint.c @@ -136,7 +136,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr, { LONGEST high; - if (get_discrete_bounds (index_type, &low, &high) < 0) + if (!get_discrete_bounds (index_type, &low, &high)) len = 1; else if (low > high) { diff --git a/gdb/c-lang.c b/gdb/c-lang.c index 2a17e007fd0..c2db47e11e2 100644 --- a/gdb/c-lang.c +++ b/gdb/c-lang.c @@ -698,8 +698,8 @@ evaluate_subexp_c (struct type *expect_type, struct expression *exp, LONGEST low_bound, high_bound; int element_size = TYPE_LENGTH (type); - if (get_discrete_bounds (expect_type->index_type (), - &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (expect_type->index_type (), + &low_bound, &high_bound)) { low_bound = 0; high_bound = (TYPE_LENGTH (expect_type) / element_size) - 1; diff --git a/gdb/eval.c b/gdb/eval.c index d02813eec52..5eb6ce1a263 100644 --- a/gdb/eval.c +++ b/gdb/eval.c @@ -1386,7 +1386,7 @@ evaluate_subexp_standard (struct type *expect_type, int element_size = TYPE_LENGTH (check_typedef (element_type)); LONGEST low_bound, high_bound, index; - if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (range_type, &low_bound, &high_bound)) { low_bound = 0; high_bound = (TYPE_LENGTH (type) / element_size) - 1; @@ -1426,7 +1426,7 @@ evaluate_subexp_standard (struct type *expect_type, || check_type->code () == TYPE_CODE_TYPEDEF) check_type = TYPE_TARGET_TYPE (check_type); - if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (element_type, &low_bound, &high_bound)) error (_("(power)set type with unknown size")); memset (valaddr, '\0', TYPE_LENGTH (type)); for (tem = 0; tem < nargs; tem++) diff --git a/gdb/f-array-walker.h b/gdb/f-array-walker.h index 417f9f07980..c202df6c65f 100644 --- a/gdb/f-array-walker.h +++ b/gdb/f-array-walker.h @@ -42,7 +42,7 @@ public: /* Get the range, and extract the bounds. */ struct type *range_type = type->index_type (); - if (get_discrete_bounds (range_type, &m_lowerbound, &m_upperbound) < 0) + if (!get_discrete_bounds (range_type, &m_lowerbound, &m_upperbound)) error ("unable to read array bounds"); /* Figure out the stride for this array. */ @@ -198,7 +198,7 @@ private: /* Extract the range, and get lower and upper bounds. */ struct type *range_type = check_typedef (type)->index_type (); LONGEST lowerbound, upperbound; - if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0) + if (!get_discrete_bounds (range_type, &lowerbound, &upperbound)) error ("failed to get range bounds"); /* CALC is used to calculate the offsets for each element in this diff --git a/gdb/f-lang.c b/gdb/f-lang.c index 6771758bacb..bbece501799 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -1404,7 +1404,7 @@ fortran_adjust_dynamic_array_base_address_hack (struct type *type, tmp_type = check_typedef (tmp_type); struct type *range_type = tmp_type->index_type (); LONGEST lowerbound, upperbound, stride; - if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0) + if (!get_discrete_bounds (range_type, &lowerbound, &upperbound)) error ("failed to get range bounds"); /* Figure out the stride for this dimension. */ diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 0c91edd48a5..f1b19b58aab 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1036,15 +1036,9 @@ has_static_range (const struct range_bounds *bounds) && bounds->stride.kind () == PROP_CONST); } +/* See gdbtypes.h. */ -/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type - TYPE. - - Return 1 if type is a range type with two defined, constant bounds. - Else, return 0 if it is discrete (and bounds will fit in LONGEST). - Else, return -1. */ - -int +bool get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) { type = check_typedef (type); @@ -1055,7 +1049,7 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) constant bounds. */ if (type->bounds ()->low.kind () != PROP_CONST || type->bounds ()->high.kind () != PROP_CONST) - return -1; + return false; *lowp = type->bounds ()->low.const_val (); *highp = type->bounds ()->high.const_val (); @@ -1065,20 +1059,17 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) gdb::optional low_pos = discrete_position (TYPE_TARGET_TYPE (type), *lowp); - if (!low_pos.has_value ()) - return 0; - - *lowp = *low_pos; + if (low_pos.has_value ()) + *lowp = *low_pos; gdb::optional high_pos = discrete_position (TYPE_TARGET_TYPE (type), *highp); - if (!high_pos.has_value ()) - return 0; - - *highp = *high_pos; + if (high_pos.has_value ()) + *highp = *high_pos; } - return 1; + return true; + case TYPE_CODE_ENUM: if (type->num_fields () > 0) { @@ -1104,19 +1095,22 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) *lowp = 0; *highp = -1; } - return 0; + return true; + case TYPE_CODE_BOOL: *lowp = 0; *highp = 1; - return 0; + return true; + case TYPE_CODE_INT: if (TYPE_LENGTH (type) > sizeof (LONGEST)) /* Too big */ - return -1; + return false; + if (!type->is_unsigned ()) { *lowp = -(1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1)); *highp = -*lowp - 1; - return 0; + return true; } /* fall through */ case TYPE_CODE_CHAR: @@ -1126,9 +1120,10 @@ get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) if TYPE_LENGTH (type) == sizeof (LONGEST). */ *highp = 1 << (TYPE_LENGTH (type) * TARGET_CHAR_BIT - 1); *highp = (*highp - 1) | *highp; - return 0; + return true; + default: - return -1; + return false; } } @@ -1140,13 +1135,11 @@ get_array_bounds (struct type *type, LONGEST *low_bound, LONGEST *high_bound) struct type *index = type->index_type (); LONGEST low = 0; LONGEST high = 0; - int res; if (index == NULL) return false; - res = get_discrete_bounds (index, &low, &high); - if (res == -1) + if (!get_discrete_bounds (index, &low, &high)) return false; if (low_bound) @@ -1223,8 +1216,9 @@ update_static_array_size (struct type *type) if (stride == 0) stride = range_type->bit_stride (); - if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (range_type, &low_bound, &high_bound)) low_bound = high_bound = 0; + element_type = check_typedef (TYPE_TARGET_TYPE (type)); /* Be careful when setting the array length. Ada arrays can be empty arrays with the high_bound being smaller than the low_bound. @@ -1420,8 +1414,9 @@ create_set_type (struct type *result_type, struct type *domain_type) { LONGEST low_bound, high_bound, bit_length; - if (get_discrete_bounds (domain_type, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (domain_type, &low_bound, &high_bound)) low_bound = high_bound = 0; + bit_length = high_bound - low_bound + 1; TYPE_LENGTH (result_type) = (bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index e3048565270..19d07405d63 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -2466,7 +2466,13 @@ extern struct type *lookup_template_type (const char *, struct type *, extern int get_vptr_fieldno (struct type *, struct type **); -extern int get_discrete_bounds (struct type *, LONGEST *, LONGEST *); +/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type + TYPE. + + Return true if the two bounds are available, false otherwise. */ + +extern bool get_discrete_bounds (struct type *type, LONGEST *lowp, + LONGEST *highp); /* Assuming TYPE is a simple, non-empty array type, compute its upper and lower bound. Save the low bound into LOW_BOUND if not NULL. diff --git a/gdb/m2-typeprint.c b/gdb/m2-typeprint.c index 8fbcdf4c603..20a3d131476 100644 --- a/gdb/m2-typeprint.c +++ b/gdb/m2-typeprint.c @@ -372,7 +372,7 @@ m2_is_long_set (struct type *type) This should be integrated into gdbtypes.c inside get_discrete_bounds. */ -static int +static bool m2_get_discrete_bounds (struct type *type, LONGEST *lowp, LONGEST *highp) { type = check_typedef (type); @@ -419,7 +419,7 @@ m2_is_long_set_of_type (struct type *type, struct type **of_type) l1 = type->field (i).type ()->bounds ()->low.const_val (); h1 = type->field (len - 1).type ()->bounds ()->high.const_val (); *of_type = target; - if (m2_get_discrete_bounds (target, &l2, &h2) >= 0) + if (m2_get_discrete_bounds (target, &l2, &h2)) return (l1 == l2 && h1 == h2); error (_("long_set failed to find discrete bounds for its subtype")); return 0; diff --git a/gdb/m2-valprint.c b/gdb/m2-valprint.c index 96dc18119cf..542fa492d06 100644 --- a/gdb/m2-valprint.c +++ b/gdb/m2-valprint.c @@ -97,7 +97,7 @@ m2_print_long_set (struct type *type, const gdb_byte *valaddr, target = TYPE_TARGET_TYPE (range); - if (get_discrete_bounds (range, &field_low, &field_high) >= 0) + if (get_discrete_bounds (range, &field_low, &field_high)) { for (i = low_bound; i <= high_bound; i++) { @@ -137,7 +137,7 @@ m2_print_long_set (struct type *type, const gdb_byte *valaddr, if (field == len) break; range = type->field (field).type ()->index_type (); - if (get_discrete_bounds (range, &field_low, &field_high) < 0) + if (!get_discrete_bounds (range, &field_low, &field_high)) break; target = TYPE_TARGET_TYPE (range); } @@ -399,7 +399,7 @@ m2_language::value_print_inner (struct value *val, struct ui_file *stream, fputs_filtered ("{", stream); - i = get_discrete_bounds (range, &low_bound, &high_bound); + i = get_discrete_bounds (range, &low_bound, &high_bound) ? 0 : -1; maybe_bad_bstring: if (i < 0) { diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c index 428b2efc656..8f785b71ea4 100644 --- a/gdb/p-valprint.c +++ b/gdb/p-valprint.c @@ -343,7 +343,8 @@ pascal_value_print_inner (struct value *val, struct ui_file *stream, fputs_filtered ("[", stream); - int bound_info = get_discrete_bounds (range, &low_bound, &high_bound); + int bound_info = (get_discrete_bounds (range, &low_bound, &high_bound) + ? 0 : -1); if (low_bound == 0 && high_bound == -1 && TYPE_LENGTH (type) > 0) { /* If we know the size of the set type, we can figure out the diff --git a/gdb/valarith.c b/gdb/valarith.c index 5b2bf1889ed..077bcb41dd8 100644 --- a/gdb/valarith.c +++ b/gdb/valarith.c @@ -1949,7 +1949,7 @@ value_bit_index (struct type *type, const gdb_byte *valaddr, int index) unsigned rel_index; struct type *range = type->index_type (); - if (get_discrete_bounds (range, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (range, &low_bound, &high_bound)) return -2; if (index < low_bound || index > high_bound) return -1; diff --git a/gdb/valops.c b/gdb/valops.c index 4d0e002b20d..09e97d2d3b9 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -453,7 +453,7 @@ value_cast (struct type *type, struct value *arg2) int val_length = TYPE_LENGTH (type2); LONGEST low_bound, high_bound, new_length; - if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0) + if (!get_discrete_bounds (range_type, &low_bound, &high_bound)) low_bound = 0, high_bound = 0; new_length = val_length / element_length; if (val_length % element_length != 0) @@ -3948,7 +3948,7 @@ value_slice (struct value *array, int lowbound, int length) error (_("array not associated")); range_type = array_type->index_type (); - if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0) + if (!get_discrete_bounds (range_type, &lowerbound, &upperbound)) error (_("slice from bad array or bitstring")); if (lowbound < lowerbound || length < 0 -- 2.30.2