This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: [PATCH/aarch64] Fix handling of hfa/hva arrays
- From: Yao Qi <qiyaoltc at gmail dot com>
- To: Tristan Gingold <gingold at adacore dot com>
- Cc: GDB Patches <gdb-patches at sourceware dot org>
- Date: Mon, 14 Dec 2015 12:58:59 +0000
- Subject: Re: [PATCH/aarch64] Fix handling of hfa/hva arrays
- Authentication-results: sourceware.org; auth=none
- References: <9807AC8E-AB8B-42D5-BEF8-1CF4D5731E28 at adacore dot com>
Tristan Gingold <gingold@adacore.com> writes:
> the current handling of hfa arrays is not correct: first the length comparison
> is using the size instead of the length so only array of a single float could
> be considered as an hfa.
>
> Second, where used HFA were only considered as struct/union. Incorrect
> accessor (like TYPE_NFIELDS) were used on arrays.
Hi Tristan,
Thanks for your patch. I spot this problem before, but I didn't fix it
because I can't write a test case in ada. Could you add a test case to
expose these problems you described above?
>
> Unfortunately, we donât have the setup to run the gdb testsuite on that
> processor. So this patch was only manually tested (using our own
> internal testsuite) on a slightly older version of gdb.
Your can run testsuite on aarch64 machine on gcc compile farm, as Pedro
suggested.
> @@ -932,12 +932,13 @@ is_hfa_or_hva (struct type *ty)
> {
> case TYPE_CODE_ARRAY:
> {
> - struct type *target_ty = TYPE_TARGET_TYPE (ty);
> + struct type *target_ty = check_typedef (TYPE_TARGET_TYPE (ty));
>
> if (TYPE_VECTOR (ty))
> return 0;
>
> - if (TYPE_LENGTH (ty) <= 4 /* HFA or HVA has at most 4 members. */
> + /* HFA or HVA has at most 4 members. */
> + if (TYPE_LENGTH (ty) / TYPE_LENGTH (target_ty) <= 4
> && (TYPE_CODE (target_ty) == TYPE_CODE_FLT /* HFA */
> || (TYPE_CODE (target_ty) == TYPE_CODE_ARRAY /* HVA */
> && TYPE_VECTOR (target_ty))))
We can use get_array_bounds here, and take care of empty array in ada.
We can do something like this?
+ LONGEST low_bound, high_bound;
+
+ if (get_array_bounds (ty, &low_bound, &high_bound))
+ {
+ struct type *target_ty = TYPE_TARGET_TYPE (ty);
+
+ if (low_bound > high_bound)
+ {
+ /* Empty array in Ada. */
+ return 0;
+ }
+ else if (high_bound - low_bound + 1 > 4)
+ {
+ /* There are at most 4 members in HFA. */
+ return 0;
+ }
+ else if (TYPE_CODE (target_ty) == TYPE_CODE_FLT /* HFA */
+ || (TYPE_CODE (target_ty) == TYPE_CODE_ARRAY /* HVA */
+ && TYPE_VECTOR (target_ty))))
+ return 1;
+ else
+ return 0;
+ }
+ else
+ return 0;
+
> @@ -1313,7 +1314,16 @@ aarch64_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
> case TYPE_CODE_UNION:
> if (is_hfa_or_hva (arg_type))
> {
> - int elements = TYPE_NFIELDS (arg_type);
> + int elements;
> +
> + if (TYPE_CODE (arg_type) == TYPE_CODE_ARRAY)
> + {
> + struct type *el_type;
> + el_type = check_typedef (TYPE_TARGET_TYPE (arg_type));
> + elements = TYPE_LENGTH (arg_type) / TYPE_LENGTH (el_type);
> + }
> + else
> + elements = TYPE_NFIELDS (arg_type);
The change is correct, but it would be nice to move them into
is_hfa_or_hva, so that it becomes,
static int
is_hfa_or_hva (struct type *ty, int *elenum)
*ELENUM is set to the number of elements or fields of *TY if *TY is a
Homogeneous Aggregates.
What do you think?
--
Yao (éå)