espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-05 15:17:13 +08:00
Code Issues Packages Projects Releases Wiki Activity

* dwarf2read.c (struct attribute): Increase sizes of unsnd and snd

Browse Source 
fields to allow larger integer sizes.
(read_subrange_type): Increase size of bound values.
Add logic to determine signedness based on base-type size, signedness.
(read_attribute_value): Change format for bad byte size in message.
(read_8_bytes): Increase size of result type.
(dump_die_shallow): Change format for value.
(dwarf2_get_attr_constant_value): Increase size of return type.
Correct comment.
* gdbtypes.c (create_range_type): Change API to increase size of
bounds. struct field -> union field.
Always take signedness from base type.
(check_typedef): Use new API for TYPE_LOW_BOUND, TYPE_HIGH_BOUND.
(recursive_dump_type, copy_type_recursive): Adjust to new
representation of range types.
* gdbtypes.h (fields_or_bounds): New union containing struct field and
new struct range_bounds, used for range types.
(TYPE_RANGE_DATA): New macro to access range_bounds member.
(TYPE_LOW_BOUND, TYPE_HIGH_BOUND): Represent with new TYPE_RANGE_DATA.
(TYPE_LOW_BOUND_UNDEFINED, TYPE_HIGH_BOUND_UNDEFINED): New macros,
taking over the job of TYPE_FIELD_ARTIFICIAL for range bounds.
(SET_TYPE_LOW_BOUND, SET_TYPE_HIGH_BOUND, SET_TYPE_LOW_BOUND_DEFINED)
(SET_TYPE_HIGH_BOUND_DEFINED): New macros.
(TYPE_FIELDS, TYPE_BASECLASS, TYPE_BASECLASS_NAME, TYPE_FIELD)
(TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED)
(TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED, TYPE_ARRAY_UPPER_BOUND_VALUE)
(TYPE_ARRAY_LOWER_BOUND_VALUE):	Adjust to new representation.
(create_range_type): Adjust API.
* ada-lang.c (ada_modulus): Use new extended bound values.
(discrete_type_low_bound): Rename to...
(ada_discrete_type_low_bound): ... and make external.
(discrete_type_high_bound): Rename to...
(ada_discrete_type_high_bound): ... and make external.
(ada_value_slice_from_ptr, ada_array_bound_from_type)
(ada_evaluate_subexp, to_fixed_range_type):
Use ada_discrete_type_low_bound, ada_discrete_type_high_bound.
* ada-typeprint.c (print_range): Use ada_discrete_type_low_bound,
ada_discrete_type_high_bound.  Don't look at field count, which
is no longer meaningful.  Print bounds whenever argument is a range
or enumeration.
* ada-lang.h (ada_discrete_type_low_bound,ada_discrete_type_high_bound):
Declare.
* varobj.c (c_describe_child): Adjust to render larger values.
* mdebugread.c (parse_type): Use proper abstractions for range types:
TYPE_RANGE_DATA, SET_TYPE_LOW_BOUND_DEFINED,
SET_TYPE_HIGH_BOUND_DEFINED.
* p-typeprint.c (pascal_type_print_varspec_prefix): Use larger format
for bounds.
This commit is contained in:
Paul N. Hilfinger
2009-12-14 06:19:13 +00:00
parent d48d911fbf
commit 43bbcdc2bc
10 changed files with 246 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
gdb/ChangeLog
View File

@ -1,3 +1,54 @@
2009-12-13 Paul N. Hilfinger <hilfinger@adacore.com>
* dwarf2read.c (struct attribute): Increase sizes of unsnd and snd
fields to allow larger integer sizes.
(read_subrange_type): Increase size of bound values.
Add logic to determine signedness based on base-type size, signedness.
(read_attribute_value): Change format for bad byte size in message.
(read_8_bytes): Increase size of result type.
(dump_die_shallow): Change format for value.
(dwarf2_get_attr_constant_value): Increase size of return type.
Correct comment.
* gdbtypes.c (create_range_type): Change API to increase size of
bounds. struct field -> union field.
Always take signedness from base type.
(check_typedef): Use new API for TYPE_LOW_BOUND, TYPE_HIGH_BOUND.
(recursive_dump_type, copy_type_recursive): Adjust to new
representation of range types.
* gdbtypes.h (fields_or_bounds): New union containing struct field and
new struct range_bounds, used for range types.
(TYPE_RANGE_DATA): New macro to access range_bounds member.
(TYPE_LOW_BOUND, TYPE_HIGH_BOUND): Represent with new TYPE_RANGE_DATA.
(TYPE_LOW_BOUND_UNDEFINED, TYPE_HIGH_BOUND_UNDEFINED): New macros,
taking over the job of TYPE_FIELD_ARTIFICIAL for range bounds.
(SET_TYPE_LOW_BOUND, SET_TYPE_HIGH_BOUND, SET_TYPE_LOW_BOUND_DEFINED)
(SET_TYPE_HIGH_BOUND_DEFINED): New macros.
(TYPE_FIELDS, TYPE_BASECLASS, TYPE_BASECLASS_NAME, TYPE_FIELD)
(TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED)
(TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED, TYPE_ARRAY_UPPER_BOUND_VALUE)
(TYPE_ARRAY_LOWER_BOUND_VALUE): Adjust to new representation.
(create_range_type): Adjust API.
* ada-lang.c (ada_modulus): Use new extended bound values.
(discrete_type_low_bound): Rename to...
(ada_discrete_type_low_bound): ... and make external.
(discrete_type_high_bound): Rename to...
(ada_discrete_type_high_bound): ... and make external.
(ada_value_slice_from_ptr, ada_array_bound_from_type)
(ada_evaluate_subexp, to_fixed_range_type):
Use ada_discrete_type_low_bound, ada_discrete_type_high_bound.
* ada-typeprint.c (print_range): Use ada_discrete_type_low_bound,
ada_discrete_type_high_bound. Don't look at field count, which
is no longer meaningful. Print bounds whenever argument is a range
or enumeration.
* ada-lang.h (ada_discrete_type_low_bound,ada_discrete_type_high_bound):
Declare.
* varobj.c (c_describe_child): Adjust to render larger values.
* mdebugread.c (parse_type): Use proper abstractions for range types:
TYPE_RANGE_DATA, SET_TYPE_LOW_BOUND_DEFINED,
SET_TYPE_HIGH_BOUND_DEFINED.
* p-typeprint.c (pascal_type_print_varspec_prefix): Use larger format
for bounds.
2009-12-11 Michael Snyder <msnyder@vmware.com> 2009-12-11 Michael Snyder <msnyder@vmware.com>
* main.c (captured_main): Indentation. * main.c (captured_main): Indentation.

62
gdb/ada-lang.c
View File

@ -597,8 +597,8 @@ min_of_type (struct type *t)
} }
/* The largest value in the domain of TYPE, a discrete type, as an integer. */ /* The largest value in the domain of TYPE, a discrete type, as an integer. */
static LONGEST LONGEST
discrete_type_high_bound (struct type *type) ada_discrete_type_high_bound (struct type *type)
{ {
switch (TYPE_CODE (type)) switch (TYPE_CODE (type))
{ {
@ -612,13 +612,13 @@ discrete_type_high_bound (struct type *type)
case TYPE_CODE_INT: case TYPE_CODE_INT:
return max_of_type (type); return max_of_type (type);
default: default:
error (_("Unexpected type in discrete_type_high_bound.")); error (_("Unexpected type in ada_discrete_type_high_bound."));
} }
} }
/* The largest value in the domain of TYPE, a discrete type, as an integer. */ /* The largest value in the domain of TYPE, a discrete type, as an integer. */
static LONGEST LONGEST
discrete_type_low_bound (struct type *type) ada_discrete_type_low_bound (struct type *type)
{ {
switch (TYPE_CODE (type)) switch (TYPE_CODE (type))
{ {
@ -632,7 +632,7 @@ discrete_type_low_bound (struct type *type)
case TYPE_CODE_INT: case TYPE_CODE_INT:
return min_of_type (type); return min_of_type (type);
default: default:
error (_("Unexpected type in discrete_type_low_bound.")); error (_("Unexpected type in ada_discrete_type_low_bound."));
} }
} }
@ -2399,7 +2399,7 @@ ada_value_slice_from_ptr (struct value *array_ptr, struct type *type,
int low, int high) int low, int high)
{ {
CORE_ADDR base = value_as_address (array_ptr) CORE_ADDR base = value_as_address (array_ptr)
+ ((low - TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type))) + ((low - ada_discrete_type_low_bound (TYPE_INDEX_TYPE (type)))
* TYPE_LENGTH (TYPE_TARGET_TYPE (type))); * TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
struct type *index_type = struct type *index_type =
create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (type)), create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (type)),
@ -2542,7 +2542,6 @@ static LONGEST
ada_array_bound_from_type (struct type * arr_type, int n, int which) ada_array_bound_from_type (struct type * arr_type, int n, int which)
{ {
struct type *type, *elt_type, *index_type_desc, *index_type; struct type *type, *elt_type, *index_type_desc, *index_type;
LONGEST retval;
int i; int i;
gdb_assert (which == 0 || which == 1); gdb_assert (which == 0 || which == 1);
@ -2569,22 +2568,10 @@ ada_array_bound_from_type (struct type * arr_type, int n, int which)
else else
index_type = TYPE_INDEX_TYPE (elt_type); index_type = TYPE_INDEX_TYPE (elt_type);
switch (TYPE_CODE (index_type)) return
{ (LONGEST) (which == 0
case TYPE_CODE_RANGE: ? ada_discrete_type_low_bound (index_type)
retval = which == 0 ? TYPE_LOW_BOUND (index_type) : ada_discrete_type_high_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"));
}
return retval;
} }
/* Given that arr is an array value, returns the lower bound of the /* Given that arr is an array value, returns the lower bound of the
@ -9262,10 +9249,10 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
error (_("unexpected attribute encountered")); error (_("unexpected attribute encountered"));
case OP_ATR_FIRST: case OP_ATR_FIRST:
return value_from_longest return value_from_longest
(range_type, discrete_type_low_bound (range_type)); (range_type, ada_discrete_type_low_bound (range_type));
case OP_ATR_LAST: case OP_ATR_LAST:
return value_from_longest return value_from_longest
(range_type, discrete_type_high_bound (range_type)); (range_type, ada_discrete_type_high_bound (range_type));
case OP_ATR_LENGTH: case OP_ATR_LENGTH:
error (_("the 'length attribute applies only to array types")); error (_("the 'length attribute applies only to array types"));
} }
@ -9839,14 +9826,14 @@ to_fixed_range_type (char *name, struct value *dval, struct type *orig_type)
subtype_info = strstr (name, "___XD"); subtype_info = strstr (name, "___XD");
if (subtype_info == NULL) if (subtype_info == NULL)
{ {
LONGEST L = discrete_type_low_bound (raw_type); LONGEST L = ada_discrete_type_low_bound (raw_type);
LONGEST U = discrete_type_high_bound (raw_type); LONGEST U = ada_discrete_type_high_bound (raw_type);
if (L < INT_MIN || U > INT_MAX) if (L < INT_MIN || U > INT_MAX)
return raw_type; return raw_type;
else else
return create_range_type (alloc_type_copy (orig_type), raw_type, return create_range_type (alloc_type_copy (orig_type), raw_type,
discrete_type_low_bound (raw_type), ada_discrete_type_low_bound (raw_type),
discrete_type_high_bound (raw_type)); ada_discrete_type_high_bound (raw_type));
} }
else else
{ {
@ -9972,20 +9959,7 @@ ada_modulus_from_name (struct type *type, ULONGEST *modulus)
ULONGEST ULONGEST
ada_modulus (struct type *type) ada_modulus (struct type *type)
{ {
ULONGEST modulus; return (ULONGEST) TYPE_HIGH_BOUND (type) + 1;
/* Normally, the modulus of a modular type is equal to the value of
its upper bound + 1. However, the upper bound is currently stored
as an int, which is not always big enough to hold the actual bound
value. To workaround this, try to take advantage of the encoding
that GNAT uses with with discrete types. To avoid some unnecessary
parsing, we do this only when the size of TYPE is greater than
the size of the field holding the bound. */
if (TYPE_LENGTH (type) > sizeof (TYPE_HIGH_BOUND (type))
&& ada_modulus_from_name (type, &modulus))
return modulus;
return (ULONGEST) (unsigned int) TYPE_HIGH_BOUND (type) + 1;
} }

4
gdb/ada-lang.h
View File

@ -199,6 +199,10 @@ extern int ada_is_array_descriptor_type (struct type *);
extern int ada_is_bogus_array_descriptor (struct type *); extern int ada_is_bogus_array_descriptor (struct type *);
extern LONGEST ada_discrete_type_low_bound (struct type *);
extern LONGEST ada_discrete_type_high_bound (struct type *);
extern char *ada_decode_symbol (const struct general_symbol_info*); extern char *ada_decode_symbol (const struct general_symbol_info*);
extern const char *ada_decode (const char*); extern const char *ada_decode (const char*);

49
gdb/ada-typeprint.c
View File

@ -114,53 +114,32 @@ decoded_type_name (struct type *type)
} }
} }
/* Print range type TYPE on STREAM. */ /* Print TYPE on STREAM, preferably as a range. */
static void static void
print_range (struct type *type, struct ui_file *stream) print_range (struct type *type, struct ui_file *stream)
{ {
struct type *target_type; switch (TYPE_CODE (type))
target_type = TYPE_TARGET_TYPE (type);
if (target_type == NULL)
target_type = type;
switch (TYPE_CODE (target_type))
{ {
case TYPE_CODE_RANGE: case TYPE_CODE_RANGE:
case TYPE_CODE_INT:
case TYPE_CODE_BOOL:
case TYPE_CODE_CHAR:
case TYPE_CODE_ENUM: case TYPE_CODE_ENUM:
{
struct type *target_type;
target_type = TYPE_TARGET_TYPE (type);
if (target_type == NULL)
target_type = type;
ada_print_scalar (target_type, ada_discrete_type_low_bound (type),
stream);
fprintf_filtered (stream, " .. ");
ada_print_scalar (target_type, ada_discrete_type_high_bound (type),
stream);
}
break; break;
default: default:
target_type = NULL;
break;
}
if (TYPE_NFIELDS (type) < 2)
{
/* A range needs at least 2 bounds to be printed. If there are less
than 2, just print the type name instead of the range itself.
This check handles cases such as characters, for example.
If the name is not defined, then we don't print anything.
*/
fprintf_filtered (stream, "%.*s", fprintf_filtered (stream, "%.*s",
ada_name_prefix_len (TYPE_NAME (type)), ada_name_prefix_len (TYPE_NAME (type)),
TYPE_NAME (type)); TYPE_NAME (type));
} break;
else
{
/* 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 = (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, " .. ");
ada_print_scalar (target_type, upper_bound, stream);
} }
} }

31
gdb/dwarf2read.c
View File

@ -549,8 +549,8 @@ struct attribute
{ {
char *str; char *str;
struct dwarf_block *blk; struct dwarf_block *blk;
unsigned long unsnd; ULONGEST unsnd;
long int snd; LONGEST snd;
CORE_ADDR addr; CORE_ADDR addr;
struct signatured_type *signatured_type; struct signatured_type *signatured_type;
} }
@ -1065,7 +1065,7 @@ static int is_ref_attr (struct attribute *);
static unsigned int dwarf2_get_ref_die_offset (struct attribute *); static unsigned int dwarf2_get_ref_die_offset (struct attribute *);
static int dwarf2_get_attr_constant_value (struct attribute *, int); static LONGEST dwarf2_get_attr_constant_value (struct attribute *, int);
static struct die_info *follow_die_ref_or_sig (struct die_info *, static struct die_info *follow_die_ref_or_sig (struct die_info *,
struct attribute *, struct attribute *,
@ -6041,9 +6041,10 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
struct type *base_type; struct type *base_type;
struct type *range_type; struct type *range_type;
struct attribute *attr; struct attribute *attr;
int low = 0; LONGEST low = 0;
int high = -1; LONGEST high = -1;
char *name; char *name;
LONGEST negative_mask;
base_type = die_type (die, cu); base_type = die_type (die, cu);
if (TYPE_CODE (base_type) == TYPE_CODE_VOID) if (TYPE_CODE (base_type) == TYPE_CODE_VOID)
@ -6090,6 +6091,13 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
high = dwarf2_get_attr_constant_value (attr, 1); high = dwarf2_get_attr_constant_value (attr, 1);
} }
negative_mask =
(LONGEST) -1 << (TYPE_LENGTH (base_type) * TARGET_CHAR_BIT - 1);
if (!TYPE_UNSIGNED (base_type) && (low & negative_mask))
low |= negative_mask;
if (!TYPE_UNSIGNED (base_type) && (high & negative_mask))
high |= negative_mask;
range_type = create_range_type (NULL, base_type, low, high); range_type = create_range_type (NULL, base_type, low, high);
name = dwarf2_name (die, cu); name = dwarf2_name (die, cu);
@ -7127,8 +7135,8 @@ read_attribute_value (struct attribute *attr, unsigned form,
{ {
complaint complaint
(&symfile_complaints, (&symfile_complaints,
_("Suspicious DW_AT_byte_size value treated as zero instead of 0x%lx"), _("Suspicious DW_AT_byte_size value treated as zero instead of %s"),
DW_UNSND (attr)); hex_string (DW_UNSND (attr)));
DW_UNSND (attr) = 0; DW_UNSND (attr) = 0;
} }
@ -10107,7 +10115,8 @@ dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
case DW_FORM_data8: case DW_FORM_data8:
case DW_FORM_udata: case DW_FORM_udata:
case DW_FORM_sdata: case DW_FORM_sdata:
fprintf_unfiltered (f, "constant: %ld", DW_UNSND (&die->attrs[i])); fprintf_unfiltered (f, "constant: %s",
pulongest (DW_UNSND (&die->attrs[i])));
break; break;
case DW_FORM_sig8: case DW_FORM_sig8:
if (DW_SIGNATURED_TYPE (&die->attrs[i]) != NULL) if (DW_SIGNATURED_TYPE (&die->attrs[i]) != NULL)
@ -10230,10 +10239,10 @@ dwarf2_get_ref_die_offset (struct attribute *attr)
return 0; return 0;
} }
/* Return the constant value held by the given attribute. Return -1 /* Return the constant value held by ATTR. Return DEFAULT_VALUE if
if the value held by the attribute is not constant. */ * the value held by the attribute is not constant. */
static int static LONGEST
dwarf2_get_attr_constant_value (struct attribute *attr, int default_value) dwarf2_get_attr_constant_value (struct attribute *attr, int default_value)
{ {
if (attr->form == DW_FORM_sdata) if (attr->form == DW_FORM_sdata)

60
gdb/gdbtypes.c
View File

@ -711,7 +711,7 @@ allocate_stub_method (struct type *type)
struct type * struct type *
create_range_type (struct type *result_type, struct type *index_type, create_range_type (struct type *result_type, struct type *index_type,
int low_bound, int high_bound) LONGEST low_bound, LONGEST high_bound)
{ {
if (result_type == NULL) if (result_type == NULL)
result_type = alloc_type_copy (index_type); result_type = alloc_type_copy (index_type);
@ -721,10 +721,8 @@ create_range_type (struct type *result_type, struct type *index_type,
TYPE_TARGET_STUB (result_type) = 1; TYPE_TARGET_STUB (result_type) = 1;
else else
TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type)); TYPE_LENGTH (result_type) = TYPE_LENGTH (check_typedef (index_type));
TYPE_NFIELDS (result_type) = 2; TYPE_RANGE_DATA (result_type) = (struct range_bounds *)
TYPE_FIELDS (result_type) = TYPE_ZALLOC (result_type, TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
TYPE_NFIELDS (result_type)
* sizeof (struct field));
TYPE_LOW_BOUND (result_type) = low_bound; TYPE_LOW_BOUND (result_type) = low_bound;
TYPE_HIGH_BOUND (result_type) = high_bound; TYPE_HIGH_BOUND (result_type) = high_bound;
@ -1475,17 +1473,34 @@ check_typedef (struct type *type)
/* Now recompute the length of the array type, based on its /* Now recompute the length of the array type, based on its
number of elements and the target type's length. number of elements and the target type's length.
Watch out for Ada null Ada arrays where the high bound Watch out for Ada null Ada arrays where the high bound
is smaller than the low bound. */ is smaller than the low bound. */
const int low_bound = TYPE_LOW_BOUND (range_type); const LONGEST low_bound = TYPE_LOW_BOUND (range_type);
const int high_bound = TYPE_HIGH_BOUND (range_type); const LONGEST high_bound = TYPE_HIGH_BOUND (range_type);
int nb_elements; ULONGEST len;
if (high_bound < low_bound) if (high_bound < low_bound)
nb_elements = 0; len = 0;
else else {
nb_elements = high_bound - low_bound + 1; /* For now, we conservatively take the array length to be 0
if its length exceeds UINT_MAX. The code below assumes
TYPE_LENGTH (type) = nb_elements * TYPE_LENGTH (target_type); that for x < 0, (ULONGEST) x == -x + ULONGEST_MAX + 1,
which is technically not guaranteed by C, but is usually true
(because it would be true if x were unsigned with its
high-order bit on). It uses the fact that
high_bound-low_bound is always representable in
ULONGEST and that if high_bound-low_bound+1 overflows,
it overflows to 0. We must change these tests if we
decide to increase the representation of TYPE_LENGTH
from unsigned int to ULONGEST. */
ULONGEST ulow = low_bound, uhigh = high_bound;
ULONGEST tlen = TYPE_LENGTH (target_type);
len = tlen * (uhigh - ulow + 1);
if (tlen == 0 || (len / tlen - 1 + ulow) != uhigh
|| len > UINT_MAX)
len = 0;
}
TYPE_LENGTH (type) = len;
TYPE_TARGET_STUB (type) = 0; TYPE_TARGET_STUB (type) = 0;
} }
else if (TYPE_CODE (type) == TYPE_CODE_RANGE) else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
@ -2737,6 +2752,14 @@ recursive_dump_type (struct type *type, int spaces)
recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4); recursive_dump_type (TYPE_FIELD_TYPE (type, idx), spaces + 4);
} }
} }
if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
printfi_filtered (spaces, "low %s%s high %s%s\n",
plongest (TYPE_LOW_BOUND (type)),
TYPE_LOW_BOUND_UNDEFINED (type) ? " (undefined)" : "",
plongest (TYPE_HIGH_BOUND (type)),
TYPE_HIGH_BOUND_UNDEFINED (type) ? " (undefined)" : "");
}
printfi_filtered (spaces, "vptr_basetype "); printfi_filtered (spaces, "vptr_basetype ");
gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout); gdb_print_host_address (TYPE_VPTR_BASETYPE (type), gdb_stdout);
puts_filtered ("\n"); puts_filtered ("\n");
@ -2925,6 +2948,13 @@ copy_type_recursive (struct objfile *objfile,
} }
} }
/* For range types, copy the bounds information. */
if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
*TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
}
/* Copy pointers to other types. */ /* Copy pointers to other types. */
if (TYPE_TARGET_TYPE (type)) if (TYPE_TARGET_TYPE (type))
TYPE_TARGET_TYPE (new_type) = TYPE_TARGET_TYPE (new_type) =

129
gdb/gdbtypes.h
View File

@ -447,61 +447,87 @@ struct main_type
because we can allocate the space for a type before because we can allocate the space for a type before
we know what to put in it. */ we know what to put in it. */
struct field union
{ {
union field_location struct field
{ {
/* Position of this field, counting in bits from start of union field_location
containing structure. {
For gdbarch_bits_big_endian=1 targets, it is the bit offset to the MSB. /* Position of this field, counting in bits from start of
For gdbarch_bits_big_endian=0 targets, it is the bit offset to the LSB. containing structure.
For a range bound or enum value, this is the value itself. */ For gdbarch_bits_big_endian=1 targets, it is the bit offset to the MSB.
For gdbarch_bits_big_endian=0 targets, it is the bit offset to the LSB.
For a range bound or enum value, this is the value itself. */
int bitpos; int bitpos;
/* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr /* For a static field, if TYPE_FIELD_STATIC_HAS_ADDR then physaddr
is the location (in the target) of the static field. is the location (in the target) of the static field.
Otherwise, physname is the mangled label of the static field. */ Otherwise, physname is the mangled label of the static field. */
CORE_ADDR physaddr; CORE_ADDR physaddr;
char *physname; char *physname;
/* The field location can be computed by evaluating the following DWARF /* The field location can be computed by evaluating the following DWARF
block. This can be used in Fortran variable-length arrays, for block. This can be used in Fortran variable-length arrays, for
instance. */ instance. */
struct dwarf2_locexpr_baton *dwarf_block; struct dwarf2_locexpr_baton *dwarf_block;
} }
loc; loc;
/* For a function or member type, this is 1 if the argument is marked /* For a function or member type, this is 1 if the argument is marked
artificial. Artificial arguments should not be shown to the artificial. Artificial arguments should not be shown to the
user. For TYPE_CODE_RANGE it is set if the specific bound is not user. For TYPE_CODE_RANGE it is set if the specific bound is not
defined. */ defined. */
unsigned int artificial : 1; unsigned int artificial : 1;
/* Discriminant for union field_location. */ /* Discriminant for union field_location. */
ENUM_BITFIELD(field_loc_kind) loc_kind : 2; ENUM_BITFIELD(field_loc_kind) loc_kind : 2;
/* Size of this field, in bits, or zero if not packed. /* Size of this field, in bits, or zero if not packed.
For an unpacked field, the field's type's length If non-zero in an array type, indicates the element size in
says how many bytes the field occupies. */ bits (used only in Ada at the moment).
For an unpacked field, the field's type's length
says how many bytes the field occupies. */
unsigned int bitsize : 29; unsigned int bitsize : 29;
/* In a struct or union type, type of this field. /* In a struct or union type, type of this field.
In a function or member type, type of this argument. In a function or member type, type of this argument.
In an array type, the domain-type of the array. */ In an array type, the domain-type of the array. */
struct type *type; struct type *type;
/* Name of field, value or argument. /* Name of field, value or argument.
NULL for range bounds, array domains, and member function NULL for range bounds, array domains, and member function
arguments. */ arguments. */
char *name; char *name;
} *fields;
} *fields; /* Union member used for range types. */
struct range_bounds
{
/* Low bound of range. */
LONGEST low;
/* High bound of range. */
LONGEST high;
/* Flags indicating whether the values of low and high are
valid. When true, the respective range value is
undefined. Currently used only for FORTRAN arrays. */
char low_undefined;
char high_undefined;
} *bounds;
} flds_bnds;
/* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE /* For types with virtual functions (TYPE_CODE_STRUCT), VPTR_BASETYPE
is the base class which defined the virtual function table pointer. is the base class which defined the virtual function table pointer.
@ -828,19 +854,24 @@ extern void allocate_cplus_struct_type (struct type *);
type, you need to do TYPE_CODE (check_type (this_type)). */ type, you need to do TYPE_CODE (check_type (this_type)). */
#define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code #define TYPE_CODE(thistype) TYPE_MAIN_TYPE(thistype)->code
#define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields #define TYPE_NFIELDS(thistype) TYPE_MAIN_TYPE(thistype)->nfields
#define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->fields #define TYPE_FIELDS(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields
#define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args #define TYPE_TEMPLATE_ARGS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->template_args
#define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0) #define TYPE_INDEX_TYPE(type) TYPE_FIELD_TYPE (type, 0)
#define TYPE_LOW_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 0) #define TYPE_RANGE_DATA(thistype) TYPE_MAIN_TYPE(thistype)->flds_bnds.bounds
#define TYPE_HIGH_BOUND(range_type) TYPE_FIELD_BITPOS (range_type, 1) #define TYPE_LOW_BOUND(range_type) TYPE_RANGE_DATA(range_type)->low
#define TYPE_HIGH_BOUND(range_type) TYPE_RANGE_DATA(range_type)->high
#define TYPE_LOW_BOUND_UNDEFINED(range_type) \
TYPE_RANGE_DATA(range_type)->low_undefined
#define TYPE_HIGH_BOUND_UNDEFINED(range_type) \
TYPE_RANGE_DATA(range_type)->high_undefined
/* Moto-specific stuff for FORTRAN arrays */ /* Moto-specific stuff for FORTRAN arrays */
#define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \ #define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \
(TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),1)) TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
#define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \ #define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \
(TYPE_FIELD_ARTIFICIAL(TYPE_INDEX_TYPE((arraytype)),0)) TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
#define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \ #define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
(TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype)))) (TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
@ -862,9 +893,9 @@ extern void allocate_cplus_struct_type (struct type *);
#define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff #define TYPE_CPLUS_SPECIFIC(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.cplus_stuff
#define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat #define TYPE_FLOATFORMAT(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.floatformat
#define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.calling_convention #define TYPE_CALLING_CONVENTION(thistype) TYPE_MAIN_TYPE(thistype)->type_specific.calling_convention
#define TYPE_BASECLASS(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].type #define TYPE_BASECLASS(thistype,index) TYPE_FIELD_TYPE(thistype, index)
#define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses #define TYPE_N_BASECLASSES(thistype) TYPE_CPLUS_SPECIFIC(thistype)->n_baseclasses
#define TYPE_BASECLASS_NAME(thistype,index) TYPE_MAIN_TYPE(thistype)->fields[index].name #define TYPE_BASECLASS_NAME(thistype,index) TYPE_FIELD_NAME(thistype, index)
#define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index) #define TYPE_BASECLASS_BITPOS(thistype,index) TYPE_FIELD_BITPOS(thistype,index)
#define BASETYPE_VIA_PUBLIC(thistype, index) \ #define BASETYPE_VIA_PUBLIC(thistype, index) \
((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index))) ((!TYPE_FIELD_PRIVATE(thistype, index)) && (!TYPE_FIELD_PROTECTED(thistype, index)))
@ -896,7 +927,7 @@ extern void allocate_cplus_struct_type (struct type *);
#define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial) #define FIELD_ARTIFICIAL(thisfld) ((thisfld).artificial)
#define FIELD_BITSIZE(thisfld) ((thisfld).bitsize) #define FIELD_BITSIZE(thisfld) ((thisfld).bitsize)
#define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->fields[n] #define TYPE_FIELD(thistype, n) TYPE_MAIN_TYPE(thistype)->flds_bnds.fields[n]
#define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n)) #define TYPE_FIELD_TYPE(thistype, n) FIELD_TYPE(TYPE_FIELD(thistype, n))
#define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n)) #define TYPE_FIELD_NAME(thistype, n) FIELD_NAME(TYPE_FIELD(thistype, n))
#define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n)) #define TYPE_FIELD_LOC_KIND(thistype, n) FIELD_LOC_KIND (TYPE_FIELD (thistype, n))
@ -1227,8 +1258,8 @@ extern struct type *make_function_type (struct type *, struct type **);
extern struct type *lookup_function_type (struct type *); extern struct type *lookup_function_type (struct type *);
extern struct type *create_range_type (struct type *, struct type *, int, extern struct type *create_range_type (struct type *, struct type *, LONGEST,
int); LONGEST);
extern struct type *create_array_type (struct type *, struct type *, extern struct type *create_array_type (struct type *, struct type *,
struct type *); struct type *);

8
gdb/mdebugread.c
View File

@ -1743,13 +1743,11 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
/* Deal with range types */ /* Deal with range types */
if (t->bt == btRange) if (t->bt == btRange)
{ {
TYPE_NFIELDS (tp) = 2; TYPE_NFIELDS (tp) = 0;
TYPE_FIELDS (tp) = ((struct field *) TYPE_RANGE_DATA (tp) = ((struct range_bounds *)
TYPE_ALLOC (tp, 2 * sizeof (struct field))); TYPE_ZALLOC (tp, sizeof (struct range_bounds)));
TYPE_FIELD_NAME (tp, 0) = "Low";
TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax); TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax);
ax++; ax++;
TYPE_FIELD_NAME (tp, 1) = "High";
TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax); TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax);
ax++; ax++;
} }

7
gdb/p-typeprint.c
View File

@ -267,10 +267,9 @@ pascal_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
fprintf_filtered (stream, "array "); fprintf_filtered (stream, "array ");
if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
&& !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type)) && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
fprintf_filtered (stream, "[%d..%d] ", fprintf_filtered (stream, "[%s..%s] ",
TYPE_ARRAY_LOWER_BOUND_VALUE (type), plongest (TYPE_ARRAY_LOWER_BOUND_VALUE (type)),
TYPE_ARRAY_UPPER_BOUND_VALUE (type) plongest (TYPE_ARRAY_UPPER_BOUND_VALUE (type)));
);
fprintf_filtered (stream, "of "); fprintf_filtered (stream, "of ");
break; break;

13
gdb/varobj.c
View File

@ -2793,8 +2793,9 @@ c_describe_child (struct varobj *parent, int index,
{ {
case TYPE_CODE_ARRAY: case TYPE_CODE_ARRAY:
if (cname) if (cname)
*cname = xstrprintf ("%d", index *cname = xstrdup (int_string (index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type))); + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
10, 1, 0, 0));
if (cvalue && value) if (cvalue && value)
{ {
@ -2806,9 +2807,11 @@ c_describe_child (struct varobj *parent, int index,
*ctype = get_target_type (type); *ctype = get_target_type (type);
if (cfull_expression) if (cfull_expression)
*cfull_expression = xstrprintf ("(%s)[%d]", parent_expression, *cfull_expression =
index xstrprintf ("(%s)[%s]", parent_expression,
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type))); int_string (index
+ TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
10, 1, 0, 0));
break; break;