riscv
/
binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

* ada-lang.c (decode_packed_array): Minor change to comment. 

(ada_value_slice_ptr): New function.
(ada_value_slice): New function.
(ada_evaluate_subexp): Remove XVS-suffix code from subscripting
test.  Don't know why it is there.
Change slice code to use ada_value_slice_ptr and ada_value_slice, and
to avoid dereferencing huge arrays from which one is slicing.
(empty_array): Correct to return an array rather than
a subrange value.
* ada-valprint.c (print_optional_low_bound): Don't print lower bound
on empty arrays (let'em use 'FIRST instead).
jimb-rda-nptl-branch
Paul N. Hilfinger 22 years ago
parent
19c1ef65d7
commit
0b5d887791
3 changed files with 63 additions and 44 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 14
      gdb/ChangeLog
  2. 83
      gdb/ada-lang.c
  3. 10
      gdb/ada-valprint.c

14
gdb/ChangeLog
View File

@ -1,3 +1,17 @@
2004-07-01 Paul N. Hilfinger <Hilfinger@gnat.com>
* ada-lang.c (decode_packed_array): Minor change to comment.
(ada_value_slice_ptr): New function.
(ada_value_slice): New function.
(ada_evaluate_subexp): Remove XVS-suffix code from subscripting
test. Don't know why it is there.
Change slice code to use ada_value_slice_ptr and ada_value_slice, and
to avoid dereferencing huge arrays from which one is slicing.
(empty_array): Correct to return an array rather than
a subrange value.
* ada-valprint.c (print_optional_low_bound): Don't print lower bound
on empty arrays (let'em use 'FIRST instead).
2004-07-01 Paul N. Hilfinger <Hilfinger@gnat.com>
Address complaints from gdb_ari.sh:

83
gdb/ada-lang.c
View File

@ -2170,6 +2170,37 @@ ada_value_ptr_subscript (struct value *arr, struct type *type, int arity,
return value_ind (arr);
}
/* Given that ARRAY_PTR is a pointer or reference to an array of type TYPE (the
actual type of ARRAY_PTR is ignored), returns a reference to
the Ada slice of HIGH-LOW+1 elements starting at index LOW. The lower
bound of this array is LOW, as per Ada rules. */
static struct value *
ada_value_slice_ptr (struct value *array_ptr, struct type *type,
int low, int high)
{
CORE_ADDR base = value_as_address (array_ptr)
+ ((low - TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)))
* TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
struct type *index_type =
create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (type)),
low, high);
struct type *slice_type =
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
return value_from_pointer (lookup_reference_type (slice_type), base);
}
static struct value *
ada_value_slice (struct value *array, int low, int high)
{
struct type *type = VALUE_TYPE (array);
struct type *index_type =
create_range_type (NULL, TYPE_INDEX_TYPE (type), low, high);
struct type *slice_type =
create_array_type (NULL, TYPE_TARGET_TYPE (type), index_type);
return value_cast (slice_type, value_slice (array, low, high-low+1));
}
/* If type is a record type in the form of a standard GNAT array
descriptor, returns the number of dimensions for type. If arr is a
simple array, returns the number of "array of"s that prefix its
@ -2400,8 +2431,11 @@ ada_array_length (struct value *arr, int n)
static struct value *
empty_array (struct type *arr_type, int low)
{
return allocate_value (create_range_type (NULL, TYPE_INDEX_TYPE (arr_type),
low, low - 1));
struct type *index_type =
create_range_type (NULL, TYPE_TARGET_TYPE (TYPE_INDEX_TYPE (arr_type)),
low, low - 1);
struct type *elt_type = ada_array_element_type (arr_type, 1);
return allocate_value (create_array_type (NULL, elt_type, index_type));
}
@ -8922,11 +8956,6 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
{
int arity;
/* Make sure to use the parallel ___XVS type if any.
Otherwise, we won't be able to find the array arity
and element type. */
type = ada_get_base_type (type);
arity = ada_array_arity (type);
type = ada_array_element_type (type, nargs);
if (type == NULL)
@ -8981,14 +9010,6 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
if (noside == EVAL_SKIP)
goto nosideret;
/* If this is a reference type or a pointer type, and
the target type has an XVS parallel type, then get
the real target type. */
if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_REF
|| TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_PTR)
TYPE_TARGET_TYPE (VALUE_TYPE (array)) =
ada_get_base_type (TYPE_TARGET_TYPE (VALUE_TYPE (array)));
/* If this is a reference to an aligner type, then remove all
the aligners. */
if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_REF
@ -9007,26 +9028,15 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
array = value_addr (array);
if (noside == EVAL_AVOID_SIDE_EFFECTS
&& ada_is_array_descriptor_type
(check_typedef (VALUE_TYPE (array))))
{
/* Try dereferencing the array, in case it is an access
to array. */
struct type *arrType = ada_type_of_array (array, 0);
if (arrType != NULL)
array = value_at_lazy (arrType, 0, NULL);
}
&& ada_is_array_descriptor_type (check_typedef
(VALUE_TYPE (array))))
return empty_array (ada_type_of_array (array, 0), low_bound);
array = ada_coerce_to_simple_array_ptr (array);
/* When EVAL_AVOID_SIDE_EFFECTS, we may get the bounds wrong,
but only in contexts where the value is not being requested
(FIXME?). */
if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_PTR)
{
if (noside == EVAL_AVOID_SIDE_EFFECTS)
return ada_value_ind (array);
else if (high_bound < low_bound)
if (high_bound < low_bound || noside == EVAL_AVOID_SIDE_EFFECTS)
return empty_array (TYPE_TARGET_TYPE (VALUE_TYPE (array)),
low_bound);
else
@ -9034,15 +9044,8 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
struct type *arr_type0 =
to_fixed_array_type (TYPE_TARGET_TYPE (VALUE_TYPE (array)),
NULL, 1);
struct value *item0 =
ada_value_ptr_subscript (array, arr_type0, 1,
&low_bound_val);
struct value *slice =
value_repeat (item0, high_bound - low_bound + 1);
struct type *arr_type1 = VALUE_TYPE (slice);
TYPE_LOW_BOUND (TYPE_INDEX_TYPE (arr_type1)) = low_bound;
TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (arr_type1)) += low_bound;
return slice;
return ada_value_slice_ptr (array, arr_type0,
(int) low_bound, (int) high_bound);
}
}
else if (noside == EVAL_AVOID_SIDE_EFFECTS)
@ -9050,7 +9053,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
else if (high_bound < low_bound)
return empty_array (VALUE_TYPE (array), low_bound);
else
return value_slice (array, low_bound, high_bound - low_bound + 1);
return ada_value_slice (array, (int) low_bound, (int) high_bound);
}
case UNOP_IN_RANGE:

10
gdb/ada-valprint.c
View File

@ -86,10 +86,10 @@ adjust_type_signedness (struct type *type)
TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
}
/* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
if non-standard (i.e., other than 1 for numbers, other than lower bound
of index type for enumerated type). Returns 1 if something printed,
otherwise 0. */
/* Assuming TYPE is a simple, non-empty array type, prints its lower bound
on STREAM, if non-standard (i.e., other than 1 for numbers, other
than lower bound of index type for enumerated type). Returns 1
if something printed, otherwise 0. */
static int
print_optional_low_bound (struct ui_file *stream, struct type *type)
@ -105,6 +105,8 @@ print_optional_low_bound (struct ui_file *stream, struct type *type)
if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
{
low_bound = TYPE_LOW_BOUND (index_type);
if (low_bound > TYPE_HIGH_BOUND (index_type))
return 0;
index_type = TYPE_TARGET_TYPE (index_type);
}
else

Write Preview
Loading…
Cancel
Save