From: Keven Boell <keven.boell@intel.com>
To: gdb-patches@sourceware.org
Cc: keven.boell@intel.com, sanimir.agovic@intel.com
Subject: [V2 11/23] vla: add stride support to fortran arrays.
Date: Fri, 11 Jul 2014 09:22:00 -0000 [thread overview]
Message-ID: <1405070495-6948-12-git-send-email-keven.boell@intel.com> (raw)
In-Reply-To: <1405070495-6948-1-git-send-email-keven.boell@intel.com>
2014-05-28 Sanimir Agovic <sanimir.agovic@intel.com>
Keven Boell <keven.boell@intel.com>
* dwarf2read.c (read_subrange_type): Read dynamic
stride attributes.
* gdbtypes.c (create_array_type_with_stride): Add
stride support
(create_range_type): Add stride parameter.
(create_static_range_type): Pass default stride
parameter.
(resolve_dynamic_range): Evaluate stride baton.
(resolve_dynamic_type): Adjust data location with
the value of byte stride.
* gdbtypes.h (TYPE_BYTE_STRIDE): New macro.
(TYPE_BYTE_STRIDE_BLOCK): New macro.
(TYPE_BYTE_STRIDE_LOCLIST): New macro.
(TYPE_BYTE_STRIDE_KIND): New macro.
* valarith.c (value_subscripted_rvalue): Use stride.
Change-Id: I3d810c0dc37f9d9fd84dba4c764cdefc52d8501e
Signed-off-by: Keven Boell <keven.boell@intel.com>
---
gdb/dwarf2read.c | 13 +++++++++++--
gdb/f-valprint.c | 8 +++++++-
gdb/gdbtypes.c | 39 +++++++++++++++++++++++++++++++++------
gdb/gdbtypes.h | 17 +++++++++++++++++
gdb/valarith.c | 14 +++++++++++++-
5 files changed, 81 insertions(+), 10 deletions(-)
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 9b755b2..0aed0c9 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -14734,7 +14734,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
struct type *base_type, *orig_base_type;
struct type *range_type;
struct attribute *attr;
- struct dynamic_prop low, high;
+ struct dynamic_prop low, high, stride;
int low_default_is_valid;
int high_bound_is_count = 0;
const char *name;
@@ -14754,7 +14754,9 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
low.kind = PROP_CONST;
high.kind = PROP_CONST;
+ stride.kind = PROP_CONST;
high.data.const_val = 0;
+ stride.data.const_val = 0;
/* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow
omitting DW_AT_lower_bound. */
@@ -14787,6 +14789,13 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
break;
}
+ attr = dwarf2_attr (die, DW_AT_byte_stride, cu);
+ if (attr)
+ if (!attr_to_dynamic_prop (attr, die, cu, &stride, NULL, 0))
+ complaint (&symfile_complaints, _("Missing DW_AT_byte_stride "
+ "- DIE at 0x%x [in module %s]"),
+ die->offset.sect_off, objfile_name (cu->objfile));
+
attr = dwarf2_attr (die, DW_AT_lower_bound, cu);
if (attr)
attr_to_dynamic_prop (attr, die, cu, &low, NULL, 0);
@@ -14863,7 +14872,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
&& !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))
high.data.const_val |= negative_mask;
- range_type = create_range_type (NULL, orig_base_type, &low, &high);
+ range_type = create_range_type (NULL, orig_base_type, &low, &high, &stride);
if (high_bound_is_count)
TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index 8de4070..38f32e0 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -124,8 +124,14 @@ f77_print_array_1 (int nss, int ndimensions, struct type *type,
if (nss != ndimensions)
{
- size_t dim_size = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
+ size_t dim_size;
size_t offs = 0;
+ LONGEST byte_stride = abs (TYPE_BYTE_STRIDE (range_type));
+
+ if (byte_stride)
+ dim_size = byte_stride;
+ else
+ dim_size = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
for (i = lowerbound;
(i < upperbound + 1 && (*elts) < options->print_max);
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index da773f6..3f52d61 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -805,7 +805,8 @@ allocate_stub_method (struct type *type)
struct type *
create_range_type (struct type *result_type, struct type *index_type,
const struct dynamic_prop *low_bound,
- const struct dynamic_prop *high_bound)
+ const struct dynamic_prop *high_bound,
+ const struct dynamic_prop *stride)
{
if (result_type == NULL)
result_type = alloc_type_copy (index_type);
@@ -820,6 +821,7 @@ create_range_type (struct type *result_type, struct type *index_type,
TYPE_ZALLOC (result_type, sizeof (struct range_bounds));
TYPE_RANGE_DATA (result_type)->low = *low_bound;
TYPE_RANGE_DATA (result_type)->high = *high_bound;
+ TYPE_RANGE_DATA (result_type)->stride = *stride;
if (low_bound->kind == PROP_CONST && low_bound->data.const_val >= 0)
TYPE_UNSIGNED (result_type) = 1;
@@ -841,7 +843,7 @@ struct type *
create_static_range_type (struct type *result_type, struct type *index_type,
LONGEST low_bound, LONGEST high_bound)
{
- struct dynamic_prop low, high;
+ struct dynamic_prop low, high, stride;
low.kind = PROP_CONST;
low.data.const_val = low_bound;
@@ -849,7 +851,11 @@ create_static_range_type (struct type *result_type, struct type *index_type,
high.kind = PROP_CONST;
high.data.const_val = high_bound;
- result_type = create_range_type (result_type, index_type, &low, &high);
+ stride.kind = PROP_CONST;
+ stride.data.const_val = 0;
+
+ result_type = create_range_type (result_type, index_type,
+ &low, &high, &stride);
return result_type;
}
@@ -1006,16 +1012,21 @@ create_array_type_with_stride (struct type *result_type,
if (has_static_range (TYPE_RANGE_DATA (range_type))
&& dwarf2_address_data_valid (result_type))
{
- LONGEST low_bound, high_bound;
+ LONGEST low_bound, high_bound, byte_stride;
if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
low_bound = high_bound = 0;
CHECK_TYPEDEF (element_type);
+
+ byte_stride = abs (TYPE_BYTE_STRIDE (range_type));
+
/* Be careful when setting the array length. Ada arrays can be
empty arrays with the high_bound being smaller than the low_bound.
In such cases, the array length should be zero. */
if (high_bound < low_bound)
TYPE_LENGTH (result_type) = 0;
+ else if (byte_stride > 0)
+ TYPE_LENGTH (result_type) = byte_stride * (high_bound - low_bound + 1);
else if (bit_stride > 0)
TYPE_LENGTH (result_type) =
(bit_stride * (high_bound - low_bound + 1) + 7) / 8;
@@ -1702,7 +1713,7 @@ resolve_dynamic_range (struct type *dyn_range_type, CORE_ADDR addr)
struct type *static_range_type;
const struct dynamic_prop *prop;
const struct dwarf2_locexpr_baton *baton;
- struct dynamic_prop low_bound, high_bound;
+ struct dynamic_prop low_bound, high_bound, stride;
struct type *range_copy = copy_type (dyn_range_type);
gdb_assert (TYPE_CODE (dyn_range_type) == TYPE_CODE_RANGE);
@@ -1734,10 +1745,17 @@ resolve_dynamic_range (struct type *dyn_range_type, CORE_ADDR addr)
high_bound.kind = PROP_UNDEFINED;
high_bound.data.const_val = 0;
}
+
+ prop = &TYPE_RANGE_DATA (dyn_range_type)->stride;
+ if (dwarf2_evaluate_property (prop, addr, &value))
+ {
+ stride.kind = PROP_CONST;
+ stride.data.const_val = value;
+ }
static_range_type = create_range_type (range_copy,
TYPE_TARGET_TYPE (range_copy),
- &low_bound, &high_bound);
+ &low_bound, &high_bound, &stride);
TYPE_RANGE_DATA (static_range_type)->flag_bound_evaluated = 1;
return static_range_type;
}
@@ -1940,6 +1958,15 @@ resolve_dynamic_type (struct type *type, CORE_ADDR addr)
prop = TYPE_DATA_LOCATION (resolved_type);
if (dwarf2_evaluate_property (prop, addr, &value))
{
+ struct type *range_type = TYPE_INDEX_TYPE (resolved_type);
+
+ /* Adjust the data location with the value of byte stride if set, which
+ can describe the separation between successive elements along the
+ dimension. */
+ if (TYPE_BYTE_STRIDE (range_type) < 0)
+ value += (TYPE_HIGH_BOUND (range_type) - TYPE_LOW_BOUND (range_type))
+ * TYPE_BYTE_STRIDE (range_type);
+
TYPE_DATA_LOCATION_ADDR (resolved_type) = value;
TYPE_DATA_LOCATION_KIND (resolved_type) = PROP_CONST;
}
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index bf0ae81..5818f79 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -670,6 +670,10 @@ struct main_type
struct dynamic_prop high;
+ /* * Stride of range. */
+
+ struct dynamic_prop stride;
+
/* True if HIGH range bound contains the number of elements in the
subrange. This affects how the final hight bound is computed. */
@@ -1220,6 +1224,15 @@ extern void allocate_gnat_aux_type (struct type *);
TYPE_RANGE_DATA(range_type)->high.kind
#define TYPE_LOW_BOUND_KIND(range_type) \
TYPE_RANGE_DATA(range_type)->low.kind
+#define TYPE_BYTE_STRIDE(range_type) \
+ TYPE_RANGE_DATA(range_type)->stride.data.const_val
+#define TYPE_BYTE_STRIDE_BLOCK(range_type) \
+ TYPE_RANGE_DATA(range_type)->stride.data.locexpr
+#define TYPE_BYTE_STRIDE_LOCLIST(range_type) \
+ TYPE_RANGE_DATA(range_type)->stride.data.loclist
+#define TYPE_BYTE_STRIDE_KIND(range_type) \
+ TYPE_RANGE_DATA(range_type)->stride.kind
+
/* Attribute accessors for the type data location. */
#define TYPE_DATA_LOCATION(thistype) \
@@ -1251,6 +1264,9 @@ extern void allocate_gnat_aux_type (struct type *);
TYPE_HIGH_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
#define TYPE_ARRAY_LOWER_BOUND_IS_UNDEFINED(arraytype) \
TYPE_LOW_BOUND_UNDEFINED(TYPE_INDEX_TYPE(arraytype))
+#define TYPE_ARRAY_STRIDE_IS_UNDEFINED(arraytype) \
+ (TYPE_BYTE_STRIDE(TYPE_INDEX_TYPE(arraytype)) == 0)
+
#define TYPE_ARRAY_UPPER_BOUND_VALUE(arraytype) \
(TYPE_HIGH_BOUND(TYPE_INDEX_TYPE((arraytype))))
@@ -1719,6 +1735,7 @@ extern struct type *create_array_type_with_stride
extern struct type *create_range_type (struct type *, struct type *,
const struct dynamic_prop *,
+ const struct dynamic_prop *,
const struct dynamic_prop *);
extern struct type *create_array_type (struct type *, struct type *,
diff --git a/gdb/valarith.c b/gdb/valarith.c
index 3e7685a..fb9671b 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -195,9 +195,21 @@ value_subscripted_rvalue (struct value *array, LONGEST index, int lowerbound)
struct type *array_type = check_typedef (value_type (array));
struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
unsigned int elt_size = TYPE_LENGTH (elt_type);
- unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
+ unsigned int elt_offs = longest_to_int (index - lowerbound);
+ LONGEST elt_stride = TYPE_BYTE_STRIDE (TYPE_INDEX_TYPE (array_type));
struct value *v;
+ if (elt_stride > 0)
+ elt_offs *= elt_stride;
+ else if (elt_stride < 0)
+ {
+ int offs = (elt_offs + 1) * elt_stride;
+
+ elt_offs = TYPE_LENGTH (array_type) + offs;
+ }
+ else
+ elt_offs *= elt_size;
+
if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
&& elt_offs >= TYPE_LENGTH (array_type)))
{
--
1.7.9.5
next prev parent reply other threads:[~2014-07-11 9:22 UTC|newest]
Thread overview: 51+ messages / expand[flat|nested] mbox.gz Atom feed top
2014-07-11 9:21 [V2 00/23] Fortran dynamic array support Keven Boell
2014-07-11 9:21 ` [V2 12/23] vla: add NEWS entry for " Keven Boell
2014-07-11 9:58 ` Eli Zaretskii
2014-07-11 9:21 ` [V2 19/23] test: accessing dynamic array history values Keven Boell
2014-07-11 9:21 ` [V2 08/23] vla: get dynamic array corner cases to work Keven Boell
2014-07-11 9:21 ` [V2 21/23] test: basic MI test for the dynamic array support Keven Boell
2014-07-11 9:21 ` [V2 09/23] vla: changed string length semantic Keven Boell
2014-07-18 15:38 ` Jan Kratochvil
2014-07-21 13:23 ` Keven Boell
2014-07-21 19:54 ` Jan Kratochvil
2014-07-22 15:27 ` Keven Boell
2014-07-11 9:21 ` [V2 01/23] dwarf: add dwarf3 DW_OP_push_object_address opcode Keven Boell
2014-07-11 9:21 ` [V2 16/23] test: correct ptype of dynamic arrays in Fortran Keven Boell
2014-07-11 9:21 ` [V2 05/23] vla: make field selection work with vla Keven Boell
2014-07-11 9:22 ` [V2 06/23] vla: reconstruct value to compute bounds of target type Keven Boell
2014-07-11 9:22 ` [V2 04/23] vla: make dynamic fortran arrays functional Keven Boell
2014-07-11 9:22 ` [V2 02/23] dwarf: add DW_AT_data_location support Keven Boell
2014-07-11 9:22 ` [V2 14/23] test: evaluate dynamic arrays using Fortran primitives Keven Boell
2014-07-11 9:22 ` [V2 23/23] test: stride support for dynamic arrays Keven Boell
2014-07-11 9:22 ` [V2 03/23] vla: introduce allocated/associated flags Keven Boell
2014-07-11 9:22 ` [V2 22/23] test: test sizeof for dynamic fortran arrays Keven Boell
2014-07-11 9:22 ` [V2 15/23] test: dynamic arrays passed to subroutines Keven Boell
2014-08-01 20:11 ` Jan Kratochvil
2014-08-07 6:58 ` Keven Boell
2014-08-12 6:56 ` Keven Boell
2014-07-11 9:22 ` Keven Boell [this message]
2014-07-11 9:22 ` [V2 17/23] test: evaluating allocation/association status Keven Boell
2014-07-11 9:22 ` [V2 07/23] vla: use value constructor instead of raw-buffer manipulation Keven Boell
2014-07-11 9:22 ` [V2 18/23] test: dynamic arrays passed to functions Keven Boell
2014-07-11 9:22 ` [V2 13/23] test: basic tests for dynamic array evaluations in Fortran Keven Boell
2014-07-11 9:22 ` [V2 20/23] test: dynamic string evaluations Keven Boell
2014-07-11 9:28 ` [V2 10/23] vla: get Fortran dynamic strings working Keven Boell
2014-07-11 16:23 ` [V2 00/23] Fortran dynamic array support Jan Kratochvil
2014-07-16 16:19 ` Keven Boell
2014-07-16 16:33 ` Jan Kratochvil
2014-07-18 12:33 ` Keven Boell
2014-07-18 15:19 ` Jan Kratochvil
2014-07-29 19:35 ` Crash regression(?) printing Fortran strings in bt [Re: [V2 00/23] Fortran dynamic array support] Jan Kratochvil
2014-07-29 20:51 ` Jan Kratochvil
2014-08-01 7:20 ` Keven Boell
2014-08-01 7:22 ` Jan Kratochvil
2014-08-01 21:02 ` [patch 1/2] " Jan Kratochvil
2014-08-12 6:56 ` Keven Boell
2014-08-12 21:55 ` Jan Kratochvil
2014-08-14 20:03 ` Jan Kratochvil
2014-08-20 14:09 ` Keven Boell
2014-08-20 18:24 ` Jan Kratochvil
2014-08-21 7:27 ` Keven Boell
2014-08-21 14:29 ` Jan Kratochvil
2014-08-22 7:20 ` Jan Kratochvil
2014-08-01 21:05 ` [patch 2/2] " Jan Kratochvil
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1405070495-6948-12-git-send-email-keven.boell@intel.com \
--to=keven.boell@intel.com \
--cc=gdb-patches@sourceware.org \
--cc=sanimir.agovic@intel.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox