mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-01-18 12:24:38 +08:00
Code Issues Packages Projects Releases Wiki Activity

gdb: make get_discrete_bounds return bool

Browse Source 
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
This commit is contained in:
Simon Marchi 2020-12-09 13:51:57 -05:00 committed by Simon Marchi
parent 6244c1196a
commit 1f8d288117
14 changed files with 58 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gdb/ChangeLog
View File

@ -1,3 +1,9 @@
2020-12-09 Simon Marchi <simon.marchi@efficios.com>
* gdbtypes.h (get_discrete_bounds): Return bool, adjust all
callers.
* gdbtypes.c (get_discrete_bounds): Return bool.
2020-12-09 Simon Marchi <simon.marchi@efficios.com>
* ada-lang.c (ada_value_slice_from_ptr): Adjust.

6
gdb/ada-lang.c
View File

@ -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;

2
gdb/ada-valprint.c
View File

@ -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)
{

4
gdb/c-lang.c
View File

@ -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;

4
gdb/eval.c
View File

@ -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++)

4
gdb/f-array-walker.h
View File

@ -42,7 +42,7 @@ class fortran_array_offset_calculator
/* 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 @@ class fortran_array_walker
/* 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

2
gdb/f-lang.c
View File

@ -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. */

53
gdb/gdbtypes.c
View File

@ -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<LONGEST> 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<LONGEST> 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;

8
gdb/gdbtypes.h
View File

@ -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.

4
gdb/m2-typeprint.c
View File

@ -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;

6
gdb/m2-valprint.c
View File

@ -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)
{

3
gdb/p-valprint.c
View File

@ -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

2
gdb/valarith.c
View File

@ -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;

4
gdb/valops.c
View File

@ -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