From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 14880 invoked by alias); 28 Dec 2008 14:18:37 -0000 Received: (qmail 14871 invoked by uid 22791); 28 Dec 2008 14:18:36 -0000 X-SWARE-Spam-Status: No, hits=-2.2 required=5.0 tests=AWL,BAYES_00,KAM_MX,SPF_HELO_PASS,SPF_PASS X-Spam-Check-By: sourceware.org Received: from mx2.redhat.com (HELO mx2.redhat.com) (66.187.237.31) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sun, 28 Dec 2008 14:17:46 +0000 Received: from int-mx2.corp.redhat.com (int-mx2.corp.redhat.com [172.16.27.26]) by mx2.redhat.com (8.13.8/8.13.8) with ESMTP id mBSEHeWc012241; Sun, 28 Dec 2008 09:17:40 -0500 Received: from ns3.rdu.redhat.com (ns3.rdu.redhat.com [10.11.255.199]) by int-mx2.corp.redhat.com (8.13.1/8.13.1) with ESMTP id mBSEHcBS028078; Sun, 28 Dec 2008 09:17:39 -0500 Received: from host0.dyn.jankratochvil.net (sebastian-int.corp.redhat.com [172.16.52.221]) by ns3.rdu.redhat.com (8.13.8/8.13.8) with ESMTP id mBSEHWwf005248; Sun, 28 Dec 2008 09:17:33 -0500 Received: from host0.dyn.jankratochvil.net (localhost [127.0.0.1]) by host0.dyn.jankratochvil.net (8.14.3/8.14.3) with ESMTP id mBSEHSVx011189; Sun, 28 Dec 2008 15:17:31 +0100 Received: (from jkratoch@localhost) by host0.dyn.jankratochvil.net (8.14.3/8.14.2/Submit) id mBSEHR1B011185; Sun, 28 Dec 2008 15:17:27 +0100 Date: Sun, 28 Dec 2008 14:18:00 -0000 From: Jan Kratochvil To: Joel Brobecker Cc: gdb-patches@sourceware.org, Ulrich Weigand , Jim Blandy , Tobias Burnus Subject: Re: [patch] (for VLA) Prepare for 3-fields TYPE_CODE_RANGE (TYPE_HIGH_BOUND) Message-ID: <20081228141726.GA9971@host0.dyn.jankratochvil.net> References: <20081226224219.GA3513@host0.dyn.jankratochvil.net> <20081228130836.GD4216@adacore.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20081228130836.GD4216@adacore.com> User-Agent: Mutt/1.5.18 (2008-05-17) X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2008-12/txt/msg00421.txt.bz2 On Sun, 28 Dec 2008 14:08:36 +0100, Joel Brobecker wrote: > Perhaps you could mention that this is in preparation for supporting > DW_AT_byte_stride. Done. > (in ada_array_bound_from_type): > If we raise the internal_error, I'd rather we do no assign *typep. > Can you instead compute the bound value first, and then, if we haven't > detected the internal error, assign *typep before returning the bound? Done. Checked in. Thanks, Jan 2008-12-28 Jan Kratochvil 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 ): Use TYPE_INDEX_TYPE. * mdebugread.c (parse_type): Use TYPE_LOW_BOUND, TYPE_HIGH_BOUND, * valarith.c (value_bit_index): Use TYPE_INDEX_TYPE. =================================================================== RCS file: /cvs/src/src/gdb/ada-lang.c,v retrieving revision 1.185 retrieving revision 1.186 diff -u -r1.185 -r1.186 --- src/gdb/ada-lang.c 2008/12/15 10:40:28 1.185 +++ src/gdb/ada-lang.c 2008/12/28 14:14:18 1.186 @@ -1777,11 +1777,11 @@ 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 @@ 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 @@ 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 @@ 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 @@ } 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)); + 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; + if (typep != NULL) + *typep = index_type; - return - (LONGEST) (which == 0 - ? TYPE_LOW_BOUND (index_type) - : TYPE_HIGH_BOUND (index_type)); - } + return retval; } /* Given that arr is an array value, returns the lower bound of the =================================================================== RCS file: /cvs/src/src/gdb/ada-typeprint.c,v retrieving revision 1.22 retrieving revision 1.23 diff -u -r1.22 -r1.23 --- src/gdb/ada-typeprint.c 2008/09/11 14:22:32 1.22 +++ src/gdb/ada-typeprint.c 2008/12/28 14:14:18 1.23 @@ -170,8 +170,9 @@ /* 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, " .. "); =================================================================== RCS file: /cvs/src/src/gdb/ada-valprint.c,v retrieving revision 1.44 retrieving revision 1.45 diff -u -r1.44 -r1.45 --- src/gdb/ada-valprint.c 2008/10/28 17:19:56 1.44 +++ src/gdb/ada-valprint.c 2008/12/28 14:14:19 1.45 @@ -162,7 +162,7 @@ { 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; =================================================================== RCS file: /cvs/src/src/gdb/eval.c,v retrieving revision 1.102 retrieving revision 1.103 diff -u -r1.102 -r1.103 --- src/gdb/eval.c 2008/11/04 15:32:54 1.102 +++ src/gdb/eval.c 2008/12/28 14:14:19 1.103 @@ -824,7 +824,7 @@ 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)); =================================================================== RCS file: /cvs/src/src/gdb/gdbtypes.c,v retrieving revision 1.155 retrieving revision 1.156 diff -u -r1.155 -r1.156 --- src/gdb/gdbtypes.c 2008/11/10 20:53:43 1.155 +++ src/gdb/gdbtypes.c 2008/12/28 14:14:19 1.156 @@ -711,16 +711,18 @@ 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 @@ 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 @@ } 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) =================================================================== RCS file: /cvs/src/src/gdb/gdbtypes.h,v retrieving revision 1.95 retrieving revision 1.96 diff -u -r1.95 -r1.96 --- src/gdb/gdbtypes.h 2008/10/28 17:19:56 1.95 +++ src/gdb/gdbtypes.h 2008/12/28 14:14:19 1.96 @@ -815,15 +815,15 @@ /* 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++ */ =================================================================== RCS file: /cvs/src/src/gdb/hppa-tdep.c,v retrieving revision 1.261 retrieving revision 1.262 diff -u -r1.261 -r1.262 --- src/gdb/hppa-tdep.c 2008/09/15 01:56:31 1.261 +++ src/gdb/hppa-tdep.c 2008/12/28 14:14:19 1.262 @@ -1313,7 +1313,7 @@ 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; =================================================================== RCS file: /cvs/src/src/gdb/mdebugread.c,v retrieving revision 1.96 retrieving revision 1.97 diff -u -r1.96 -r1.97 --- src/gdb/mdebugread.c 2008/10/08 12:49:12 1.96 +++ src/gdb/mdebugread.c 2008/12/28 14:14:19 1.97 @@ -1644,11 +1644,11 @@ TYPE_ALLOC (tp, 2 * sizeof (struct field))); TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"), ¤t_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"), ¤t_objfile->objfile_obstack); - TYPE_FIELD_BITPOS (tp, 1) = AUX_GET_DNHIGH (bigend, ax); + TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax); ax++; } =================================================================== RCS file: /cvs/src/src/gdb/valarith.c,v retrieving revision 1.67 retrieving revision 1.68 diff -u -r1.67 -r1.68 --- src/gdb/valarith.c 2008/09/11 14:25:49 1.67 +++ src/gdb/valarith.c 2008/12/28 14:14:19 1.68 @@ -1557,7 +1557,7 @@ 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)