darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-24 12:39:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fix TYPE_HIGH_BOUND for TYPE_CODE_RANGE using arbitrary TYPE_NFIELDS in

Browse Source 
preparation for supporting DW_AT_byte_stride.
	* ada-lang.c (packed_array_type, ada_index_type): Use TYPE_INDEX_TYPE.
	(ada_array_bound_from_type): Move `index_type' declaration to the
	function start.  New variable `retval'.  Return the bounds for
	TYPE_CODE_RANGE using TYPE_LOW_BOUND and TYPE_HIGH_BOUND.  Abort on
	invalid index type codes.
	* ada-typeprint.c (print_range): Set `upper_bound' for TYPE_CODE_RANGE
	now using TYPE_HIGH_BOUND.
	* ada-valprint.c (val_print_packed_array_elements): Use `index_type'.
	* eval.c (evaluate_subexp_standard): Use TYPE_INDEX_TYPE.
	* gdbtypes.c (create_range_type): Use TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
	refer to the number of fields only through TYPE_NFIELDS.
	(create_array_type): Use TYPE_INDEX_TYPE.
	(check_typedef): Use TYPE_INDEX_TYPE, TYPE_LOW_BOUND, TYPE_HIGH_BOUND.
	* gdbtypes.h (TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED)
	(TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED): Use TYPE_INDEX_TYPE.
	(TYPE_ARRAY_UPPER_BOUND_VALUE, TYPE_ARRAY_LOWER_BOUND_VALUE): Use
	TYPE_INDEX_TYPE, TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
	* hppa-tdep.c (hppa_alignof <TYPE_CODE_ARRAY>): Use TYPE_INDEX_TYPE.
	* mdebugread.c (parse_type): Use TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
	* valarith.c (value_bit_index): Use TYPE_INDEX_TYPE.
This commit is contained in:
Jan Kratochvil 2008-12-28 14:14:19 +00:00
parent 240ab0d8f5
commit 262452ec45
10 changed files with 79 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
gdb/ChangeLog
View File

@ -1,3 +1,28 @@
2008-12-28 Jan Kratochvil <jan.kratochvil@redhat.com>
Fix TYPE_HIGH_BOUND for TYPE_CODE_RANGE using arbitrary TYPE_NFIELDS in
preparation for supporting DW_AT_byte_stride.
* ada-lang.c (packed_array_type, ada_index_type): Use TYPE_INDEX_TYPE.
(ada_array_bound_from_type): Move `index_type' declaration to the
function start. New variable `retval'. Return the bounds for
TYPE_CODE_RANGE using TYPE_LOW_BOUND and TYPE_HIGH_BOUND. Abort on
invalid index type codes.
* ada-typeprint.c (print_range): Set `upper_bound' for TYPE_CODE_RANGE
now using TYPE_HIGH_BOUND.
* ada-valprint.c (val_print_packed_array_elements): Use `index_type'.
* eval.c (evaluate_subexp_standard): Use TYPE_INDEX_TYPE.
* gdbtypes.c (create_range_type): Use TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
refer to the number of fields only through TYPE_NFIELDS.
(create_array_type): Use TYPE_INDEX_TYPE.
(check_typedef): Use TYPE_INDEX_TYPE, TYPE_LOW_BOUND, TYPE_HIGH_BOUND.
* gdbtypes.h (TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED)
(TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED): Use TYPE_INDEX_TYPE.
(TYPE_ARRAY_UPPER_BOUND_VALUE, TYPE_ARRAY_LOWER_BOUND_VALUE): Use
TYPE_INDEX_TYPE, TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
* hppa-tdep.c (hppa_alignof <TYPE_CODE_ARRAY>): Use TYPE_INDEX_TYPE.
* mdebugread.c (parse_type): Use TYPE_LOW_BOUND, TYPE_HIGH_BOUND,
* valarith.c (value_bit_index): Use TYPE_INDEX_TYPE.
2008-12-26 Sandra Loosemore <sandra@codesourcery.com>
* breakpoint.c (update_watchpoint): Refactor to avoid compiler

62
gdb/ada-lang.c
View File

@ -1777,11 +1777,11 @@ packed_array_type (struct type *type, long *elt_bits)
new_type = alloc_type (TYPE_OBJFILE (type));
new_elt_type = packed_array_type (ada_check_typedef (TYPE_TARGET_TYPE (type)),
elt_bits);
create_array_type (new_type, new_elt_type, TYPE_FIELD_TYPE (type, 0));
create_array_type (new_type, new_elt_type, TYPE_INDEX_TYPE (type));
TYPE_FIELD_BITSIZE (new_type, 0) = *elt_bits;
TYPE_NAME (new_type) = ada_type_name (type);
if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0),
if (get_discrete_bounds (TYPE_INDEX_TYPE (type),
&low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
if (high_bound < low_bound)
@ -2468,7 +2468,7 @@ ada_index_type (struct type *type, int n)
for (i = 1; i < n; i += 1)
type = TYPE_TARGET_TYPE (type);
result_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
result_type = TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (type));
/* FIXME: The stabs type r(0,0);bound;bound in an array type
has a target type of TYPE_CODE_UNDEF. We compensate here, but
perhaps stabsread.c would make more sense. */
@ -2492,8 +2492,10 @@ static LONGEST
ada_array_bound_from_type (struct type * arr_type, int n, int which,
struct type ** typep)
{
struct type *type;
struct type *index_type_desc;
struct type *type, *index_type_desc, *index_type;
LONGEST retval;
gdb_assert (which == 0 || which == 1);
if (ada_is_packed_array_type (arr_type))
arr_type = decode_packed_array_type (arr_type);
@ -2511,10 +2513,11 @@ ada_array_bound_from_type (struct type * arr_type, int n, int which,
type = arr_type;
index_type_desc = ada_find_parallel_type (type, "___XA");
if (index_type_desc == NULL)
if (index_type_desc != NULL)
index_type = to_fixed_range_type (TYPE_FIELD_NAME (index_type_desc, n - 1),
NULL, TYPE_OBJFILE (arr_type));
else
{
struct type *index_type;
while (n > 1)
{
type = TYPE_TARGET_TYPE (type);
@ -2522,34 +2525,27 @@ ada_array_bound_from_type (struct type * arr_type, int n, int which,
}
index_type = TYPE_INDEX_TYPE (type);
if (typep != NULL)
*typep = index_type;
/* The index type is either a range type or an enumerated type.
For the range type, we have some macros that allow us to
extract the value of the low and high bounds. But they
do now work for enumerated types. The expressions used
below work for both range and enum types. */
return
(LONGEST) (which == 0
? TYPE_FIELD_BITPOS (index_type, 0)
: TYPE_FIELD_BITPOS (index_type,
TYPE_NFIELDS (index_type) - 1));
}
else
switch (TYPE_CODE (index_type))
{
struct type *index_type =
to_fixed_range_type (TYPE_FIELD_NAME (index_type_desc, n - 1),
NULL, TYPE_OBJFILE (arr_type));
if (typep != NULL)
*typep = index_type;
return
(LONGEST) (which == 0
? TYPE_LOW_BOUND (index_type)
: TYPE_HIGH_BOUND (index_type));
case TYPE_CODE_RANGE:
retval = which == 0 ? TYPE_LOW_BOUND (index_type)
: TYPE_HIGH_BOUND (index_type);
break;
case TYPE_CODE_ENUM:
retval = which == 0 ? TYPE_FIELD_BITPOS (index_type, 0)
: TYPE_FIELD_BITPOS (index_type,
TYPE_NFIELDS (index_type) - 1);
break;
default:
internal_error (__FILE__, __LINE__, _("invalid type code of index type"));
}
if (typep != NULL)
*typep = index_type;
return retval;
}
/* Given that arr is an array value, returns the lower bound of the

5
gdb/ada-typeprint.c
View File

@ -170,8 +170,9 @@ print_range (struct type *type, struct ui_file *stream)
/* We extract the range type bounds respectively from the first element
and the last element of the type->fields array */
const LONGEST lower_bound = (LONGEST) TYPE_LOW_BOUND (type);
const LONGEST upper_bound =
(LONGEST) TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1);
const LONGEST upper_bound = (TYPE_CODE (type) == TYPE_CODE_RANGE
? (LONGEST) TYPE_HIGH_BOUND (type)
: (LONGEST) TYPE_FIELD_BITPOS (type, TYPE_NFIELDS (type) - 1));
ada_print_scalar (target_type, lower_bound, stream);
fprintf_filtered (stream, " .. ");

2
gdb/ada-valprint.c
View File

@ -162,7 +162,7 @@ val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
{
LONGEST high;
if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0)
if (get_discrete_bounds (index_type, &low, &high) < 0)
len = 1;
else
len = high - low + 1;

2
gdb/eval.c
View File

@ -824,7 +824,7 @@ evaluate_subexp_standard (struct type *expect_type,
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
&& TYPE_CODE (type) == TYPE_CODE_ARRAY)
{
struct type *range_type = TYPE_FIELD_TYPE (type, 0);
struct type *range_type = TYPE_INDEX_TYPE (type);
struct type *element_type = TYPE_TARGET_TYPE (type);
struct value *array = allocate_value (expect_type);
int element_size = TYPE_LENGTH (check_typedef (element_type));

22
gdb/gdbtypes.c
View File

@ -711,16 +711,18 @@ create_range_type (struct type *result_type, struct type *index_type,
else
TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
TYPE_NFIELDS (result_type) = 2;
TYPE_FIELDS (result_type) = (struct field *)
TYPE_ALLOC (result_type, 2 * sizeof (struct field));
memset (TYPE_FIELDS (result_type), 0, 2 * sizeof (struct field));
TYPE_FIELD_BITPOS (result_type, 0) = low_bound;
TYPE_FIELD_BITPOS (result_type, 1) = high_bound;
TYPE_FIELDS (result_type) = TYPE_ALLOC (result_type,
TYPE_NFIELDS (result_type)
* sizeof (struct field));
memset (TYPE_FIELDS (result_type), 0,
TYPE_NFIELDS (result_type) * sizeof (struct field));
TYPE_LOW_BOUND (result_type) = low_bound;
TYPE_HIGH_BOUND (result_type) = high_bound;
if (low_bound >= 0)
TYPE_UNSIGNED (result_type) = 1;
return (result_type);
return result_type;
}
/* Set *LOWP and *HIGHP to the lower and upper bounds of discrete type
@ -831,7 +833,7 @@ create_array_type (struct type *result_type,
TYPE_FIELDS (result_type) =
(struct field *) TYPE_ALLOC (result_type, sizeof (struct field));
memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
TYPE_FIELD_TYPE (result_type, 0) = range_type;
TYPE_INDEX_TYPE (result_type) = range_type;
TYPE_VPTR_FIELDNO (result_type) = -1;
/* TYPE_FLAG_TARGET_STUB will take care of zero length arrays */
@ -1517,15 +1519,15 @@ check_typedef (struct type *type)
}
else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
&& TYPE_NFIELDS (type) == 1
&& (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
&& (TYPE_CODE (range_type = TYPE_INDEX_TYPE (type))
== TYPE_CODE_RANGE))
{
/* Now recompute the length of the array type, based on its
number of elements and the target type's length.
Watch out for Ada null Ada arrays where the high bound
is smaller than the low bound. */
const int low_bound = TYPE_FIELD_BITPOS (range_type, 0);
const int high_bound = TYPE_FIELD_BITPOS (range_type, 1);
const int low_bound = TYPE_LOW_BOUND (range_type);
const int high_bound = TYPE_HIGH_BOUND (range_type);
int nb_elements;
if (high_bound < low_bound)

8
gdb/gdbtypes.h
View File

@ -815,15 +815,15 @@ extern void allocate_cplus_struct_type (struct type *);
/* Moto-specific stuff for FORTRAN arrays */
#define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \
(TYPE_FIELD_ARTIFICIAL((TYPE_FIELD_TYPE((arraytype),0)),1))
(TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),1))
#define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \
(TYPE_FIELD_ARTIFICIAL((TYPE_FIELD_TYPE((arraytype),0)),0))
(TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),0))
#define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
(TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),1))
(TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
#define TYPE_ARRAY_LOWER_BOUND_VALUE(arraytype) \
(TYPE_FIELD_BITPOS((TYPE_FIELD_TYPE((arraytype),0)),0))
(TYPE_LOW_BOUND(TYPE_INDEX_TYPE((arraytype))))
/* C++ */

2
gdb/hppa-tdep.c
View File

@ -1313,7 +1313,7 @@ hppa_alignof (struct type *type)
case TYPE_CODE_FLT:
return TYPE_LENGTH (type);
case TYPE_CODE_ARRAY:
return hppa_alignof (TYPE_FIELD_TYPE (type, 0));
return hppa_alignof (TYPE_INDEX_TYPE (type));
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
max_align = 1;

4
gdb/mdebugread.c
View File

@ -1644,11 +1644,11 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
TYPE_ALLOC (tp, 2 * sizeof (struct field)));
TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"),
&current_objfile->objfile_obstack);
TYPE_FIELD_BITPOS (tp, 0) = AUX_GET_DNLOW (bigend, ax);
TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
ax++;
TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"),
&current_objfile->objfile_obstack);
TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax);
TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
ax++;
}

2
gdb/valarith.c
View File

@ -1557,7 +1557,7 @@ value_bit_index (struct type *type, const gdb_byte *valaddr, int index)
LONGEST low_bound, high_bound;
LONGEST word;
unsigned rel_index;
struct type *range = TYPE_FIELD_TYPE (type, 0);
struct type *range = TYPE_INDEX_TYPE (type);
if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
return -2;
if (index < low_bound || index > high_bound)