* [PATCH 1/3] Add frame parameter to resolve_dynamic_type
2023-03-09 17:50 [PATCH 0/3] Handle dynamic properties and static link Tom Tromey
@ 2023-03-09 17:50 ` Tom Tromey
2023-03-09 17:50 ` [PATCH 2/3] Pass a frame to value_at_lazy and value_from_contents_and_address Tom Tromey
` (2 subsequent siblings)
3 siblings, 0 replies; 5+ messages in thread
From: Tom Tromey @ 2023-03-09 17:50 UTC (permalink / raw)
To: gdb-patches
This adds a frame parameter to resolve_dynamic_type and arranges for
it to be passed through the call tree and, in particular, to all calls
to dwarf2_evaluate_property.
Nothing passes this parameter yet, so this patch should have no
visible effect.
A 'const frame_info_ptr *' is used here to avoid including frame.h
from gdbtypes.h.
---
gdb/gdbtypes.c | 71 +++++++++++++++++++++++++++++++++++-----------------------
gdb/gdbtypes.h | 6 ++++-
2 files changed, 48 insertions(+), 29 deletions(-)
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index f22ba44a538..37203b5a436 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -2190,7 +2190,8 @@ is_dynamic_type (struct type *type)
}
static struct type *resolve_dynamic_type_internal
- (struct type *type, struct property_addr_info *addr_stack, int top_level);
+ (struct type *type, struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame, int top_level);
/* Given a dynamic range type (dyn_range_type) and a stack of
struct property_addr_info elements, return a static version
@@ -2211,6 +2212,7 @@ static struct type *resolve_dynamic_type_internal
static struct type *
resolve_dynamic_range (struct type *dyn_range_type,
struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame,
int rank, bool resolve_p = true)
{
CORE_ADDR value;
@@ -2221,14 +2223,14 @@ resolve_dynamic_range (struct type *dyn_range_type,
gdb_assert (rank >= 0);
const struct dynamic_prop *prop = &dyn_range_type->bounds ()->low;
- if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value,
+ if (resolve_p && dwarf2_evaluate_property (prop, frame, addr_stack, &value,
{ (CORE_ADDR) rank }))
low_bound.set_const_val (value);
else
low_bound.set_undefined ();
prop = &dyn_range_type->bounds ()->high;
- if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value,
+ if (resolve_p && dwarf2_evaluate_property (prop, frame, addr_stack, &value,
{ (CORE_ADDR) rank }))
{
high_bound.set_const_val (value);
@@ -2242,7 +2244,7 @@ resolve_dynamic_range (struct type *dyn_range_type,
bool byte_stride_p = dyn_range_type->bounds ()->flag_is_byte_stride;
prop = &dyn_range_type->bounds ()->stride;
- if (resolve_p && dwarf2_evaluate_property (prop, NULL, addr_stack, &value,
+ if (resolve_p && dwarf2_evaluate_property (prop, frame, addr_stack, &value,
{ (CORE_ADDR) rank }))
{
stride.set_const_val (value);
@@ -2265,7 +2267,7 @@ resolve_dynamic_range (struct type *dyn_range_type,
static_target_type
= resolve_dynamic_type_internal (dyn_range_type->target_type (),
- addr_stack, 0);
+ addr_stack, frame, 0);
LONGEST bias = dyn_range_type->bounds ()->bias;
static_range_type = create_range_type_with_stride
(copy_type (dyn_range_type), static_target_type,
@@ -2296,6 +2298,7 @@ resolve_dynamic_range (struct type *dyn_range_type,
static struct type *
resolve_dynamic_array_or_string_1 (struct type *type,
struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame,
int rank, bool resolve_p)
{
CORE_ADDR value;
@@ -2325,7 +2328,7 @@ resolve_dynamic_array_or_string_1 (struct type *type,
dimension of the array. */
prop = TYPE_ALLOCATED_PROP (type);
if (prop != NULL && resolve_p
- && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ && dwarf2_evaluate_property (prop, frame, addr_stack, &value))
{
prop->set_const_val (value);
if (value == 0)
@@ -2334,7 +2337,7 @@ resolve_dynamic_array_or_string_1 (struct type *type,
prop = TYPE_ASSOCIATED_PROP (type);
if (prop != NULL && resolve_p
- && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ && dwarf2_evaluate_property (prop, frame, addr_stack, &value))
{
prop->set_const_val (value);
if (value == 0)
@@ -2343,14 +2346,15 @@ resolve_dynamic_array_or_string_1 (struct type *type,
range_type = check_typedef (type->index_type ());
range_type
- = resolve_dynamic_range (range_type, addr_stack, rank, resolve_p);
+ = resolve_dynamic_range (range_type, addr_stack, frame, rank, resolve_p);
ary_dim = check_typedef (type->target_type ());
if (ary_dim != NULL && ary_dim->code () == TYPE_CODE_ARRAY)
{
ary_dim = copy_type (ary_dim);
elt_type = resolve_dynamic_array_or_string_1 (ary_dim, addr_stack,
- rank - 1, resolve_p);
+ frame, rank - 1,
+ resolve_p);
}
else
elt_type = type->target_type ();
@@ -2358,7 +2362,7 @@ resolve_dynamic_array_or_string_1 (struct type *type,
prop = type->dyn_prop (DYN_PROP_BYTE_STRIDE);
if (prop != NULL && resolve_p)
{
- if (dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ if (dwarf2_evaluate_property (prop, frame, addr_stack, &value))
{
type->remove_dyn_prop (DYN_PROP_BYTE_STRIDE);
bit_stride = (unsigned int) (value * 8);
@@ -2385,7 +2389,8 @@ resolve_dynamic_array_or_string_1 (struct type *type,
static struct type *
resolve_dynamic_array_or_string (struct type *type,
- struct property_addr_info *addr_stack)
+ struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame)
{
CORE_ADDR value;
int rank = 0;
@@ -2399,7 +2404,7 @@ resolve_dynamic_array_or_string (struct type *type,
/* Resolve the rank property to get rank value. */
struct dynamic_prop *prop = TYPE_RANK_PROP (type);
- if (dwarf2_evaluate_property (prop, nullptr, addr_stack, &value))
+ if (dwarf2_evaluate_property (prop, frame, addr_stack, &value))
{
prop->set_const_val (value);
rank = value;
@@ -2467,7 +2472,8 @@ resolve_dynamic_array_or_string (struct type *type,
reduce the rank by 1 here. */
--rank;
- return resolve_dynamic_array_or_string_1 (type, addr_stack, rank, true);
+ return resolve_dynamic_array_or_string_1 (type, addr_stack, frame, rank,
+ true);
}
/* Resolve dynamic bounds of members of the union TYPE to static
@@ -2476,7 +2482,8 @@ resolve_dynamic_array_or_string (struct type *type,
static struct type *
resolve_dynamic_union (struct type *type,
- struct property_addr_info *addr_stack)
+ struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame)
{
struct type *resolved_type;
int i;
@@ -2500,7 +2507,7 @@ resolve_dynamic_union (struct type *type,
continue;
t = resolve_dynamic_type_internal (resolved_type->field (i).type (),
- addr_stack, 0);
+ addr_stack, frame, 0);
resolved_type->field (i).set_type (t);
struct type *real_type = check_typedef (t);
@@ -2675,7 +2682,8 @@ compute_variant_fields (struct type *type,
static struct type *
resolve_dynamic_struct (struct type *type,
- struct property_addr_info *addr_stack)
+ struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame)
{
struct type *resolved_type;
int i;
@@ -2725,7 +2733,7 @@ resolve_dynamic_struct (struct type *type,
prop.set_locexpr (&baton);
CORE_ADDR addr;
- if (dwarf2_evaluate_property (&prop, nullptr, addr_stack, &addr,
+ if (dwarf2_evaluate_property (&prop, frame, addr_stack, &addr,
{addr_stack->addr}))
resolved_type->field (i).set_loc_bitpos
(TARGET_CHAR_BIT * (addr - addr_stack->addr));
@@ -2752,7 +2760,7 @@ resolve_dynamic_struct (struct type *type,
resolved_type->field (i).set_type
(resolve_dynamic_type_internal (resolved_type->field (i).type (),
- &pinfo, 0));
+ &pinfo, frame, 0));
gdb_assert (resolved_type->field (i).loc_kind ()
== FIELD_LOC_KIND_BITPOS);
@@ -2797,6 +2805,7 @@ resolve_dynamic_struct (struct type *type,
static struct type *
resolve_dynamic_type_internal (struct type *type,
struct property_addr_info *addr_stack,
+ const frame_info_ptr &frame,
int top_level)
{
struct type *real_type = check_typedef (type);
@@ -2810,7 +2819,7 @@ resolve_dynamic_type_internal (struct type *type,
gdb::optional<CORE_ADDR> type_length;
prop = TYPE_DYNAMIC_LENGTH (type);
if (prop != NULL
- && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ && dwarf2_evaluate_property (prop, frame, addr_stack, &value))
type_length = value;
if (type->code () == TYPE_CODE_TYPEDEF)
@@ -2818,7 +2827,7 @@ resolve_dynamic_type_internal (struct type *type,
resolved_type = copy_type (type);
resolved_type->set_target_type
(resolve_dynamic_type_internal (type->target_type (), addr_stack,
- top_level));
+ frame, top_level));
}
else
{
@@ -2843,7 +2852,7 @@ resolve_dynamic_type_internal (struct type *type,
resolved_type = copy_type (type);
resolved_type->set_target_type
(resolve_dynamic_type_internal (type->target_type (),
- &pinfo, top_level));
+ &pinfo, frame, top_level));
break;
}
@@ -2851,7 +2860,8 @@ resolve_dynamic_type_internal (struct type *type,
/* Strings are very much like an array of characters, and can be
treated as one here. */
case TYPE_CODE_ARRAY:
- resolved_type = resolve_dynamic_array_or_string (type, addr_stack);
+ resolved_type = resolve_dynamic_array_or_string (type, addr_stack,
+ frame);
break;
case TYPE_CODE_RANGE:
@@ -2860,15 +2870,15 @@ resolve_dynamic_type_internal (struct type *type,
this rank value is not actually required for the resolution of
the dynamic range, otherwise, we'd be resolving this range
within the context of a dynamic array. */
- resolved_type = resolve_dynamic_range (type, addr_stack, 0);
+ resolved_type = resolve_dynamic_range (type, addr_stack, frame, 0);
break;
case TYPE_CODE_UNION:
- resolved_type = resolve_dynamic_union (type, addr_stack);
+ resolved_type = resolve_dynamic_union (type, addr_stack, frame);
break;
case TYPE_CODE_STRUCT:
- resolved_type = resolve_dynamic_struct (type, addr_stack);
+ resolved_type = resolve_dynamic_struct (type, addr_stack, frame);
break;
}
}
@@ -2885,7 +2895,7 @@ resolve_dynamic_type_internal (struct type *type,
/* Resolve data_location attribute. */
prop = TYPE_DATA_LOCATION (resolved_type);
if (prop != NULL
- && dwarf2_evaluate_property (prop, NULL, addr_stack, &value))
+ && dwarf2_evaluate_property (prop, frame, addr_stack, &value))
{
/* Start of Fortran hack. See comment in f-lang.h for what is going
on here.*/
@@ -2905,12 +2915,17 @@ resolve_dynamic_type_internal (struct type *type,
struct type *
resolve_dynamic_type (struct type *type,
gdb::array_view<const gdb_byte> valaddr,
- CORE_ADDR addr)
+ CORE_ADDR addr,
+ const frame_info_ptr *in_frame)
{
struct property_addr_info pinfo
= {check_typedef (type), valaddr, addr, NULL};
- return resolve_dynamic_type_internal (type, &pinfo, 1);
+ frame_info_ptr frame;
+ if (in_frame != nullptr)
+ frame = *in_frame;
+
+ return resolve_dynamic_type_internal (type, &pinfo, frame, 1);
}
/* See gdbtypes.h */
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index c4889a4a05b..884cdc5bfb0 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -2419,6 +2419,10 @@ extern CORE_ADDR get_pointer_type_max (struct type *);
If TYPE has no dynamic properties return TYPE; otherwise a new type with
static properties is returned.
+ If FRAME is given, it is used when evaluating dynamic properties.
+ This can be important when a static link is seen. If not given,
+ the selected frame is used.
+
For an array type, if the element type is dynamic, then that will
not be resolved. This is done because each individual element may
have a different type when resolved (depending on the contents of
@@ -2426,7 +2430,7 @@ extern CORE_ADDR get_pointer_type_max (struct type *);
true for the return value of this function. */
extern struct type *resolve_dynamic_type
(struct type *type, gdb::array_view<const gdb_byte> valaddr,
- CORE_ADDR addr);
+ CORE_ADDR addr, const frame_info_ptr *frame = nullptr);
/* * Predicate if the type has dynamic values, which are not resolved yet.
See the caveat in 'resolve_dynamic_type' to understand a scenario
--
2.39.1
^ permalink raw reply [flat|nested] 5+ messages in thread* [PATCH 2/3] Pass a frame to value_at_lazy and value_from_contents_and_address
2023-03-09 17:50 [PATCH 0/3] Handle dynamic properties and static link Tom Tromey
2023-03-09 17:50 ` [PATCH 1/3] Add frame parameter to resolve_dynamic_type Tom Tromey
@ 2023-03-09 17:50 ` Tom Tromey
2023-03-09 17:50 ` [PATCH 3/3] Use the correct frame when evaluating a dynamic property Tom Tromey
2023-03-29 16:16 ` [PATCH 0/3] Handle dynamic properties and static link Tom Tromey
3 siblings, 0 replies; 5+ messages in thread
From: Tom Tromey @ 2023-03-09 17:50 UTC (permalink / raw)
To: gdb-patches
This patch adds a 'frame' parameter to value_at_lazy and ensures that
it is passed down to the call to resolve_dynamic_type. This required
also adding a frame parameter to value_from_contents_and_address.
Nothing passes this parameter to value_at_lazy yet, so this patch
should have no visible effect.
---
gdb/valops.c | 11 ++++++-----
gdb/value.c | 6 ++++--
gdb/value.h | 14 ++++++++++----
3 files changed, 20 insertions(+), 11 deletions(-)
diff --git a/gdb/valops.c b/gdb/valops.c
index 3a1b14c3d44..e14c5d05c06 100644
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -982,14 +982,15 @@ value_one (struct type *type)
e.g. in case the type is a variable length array. */
static struct value *
-get_value_at (struct type *type, CORE_ADDR addr, int lazy)
+get_value_at (struct type *type, CORE_ADDR addr, frame_info_ptr frame,
+ int lazy)
{
struct value *val;
if (check_typedef (type)->code () == TYPE_CODE_VOID)
error (_("Attempt to dereference a generic pointer."));
- val = value_from_contents_and_address (type, NULL, addr);
+ val = value_from_contents_and_address (type, NULL, addr, frame);
if (!lazy)
val->fetch_lazy ();
@@ -1015,7 +1016,7 @@ get_value_at (struct type *type, CORE_ADDR addr, int lazy)
struct value *
value_at (struct type *type, CORE_ADDR addr)
{
- return get_value_at (type, addr, 0);
+ return get_value_at (type, addr, nullptr, 0);
}
/* See value.h. */
@@ -1034,9 +1035,9 @@ value_at_non_lval (struct type *type, CORE_ADDR addr)
e.g. in case the type is a variable length array. */
struct value *
-value_at_lazy (struct type *type, CORE_ADDR addr)
+value_at_lazy (struct type *type, CORE_ADDR addr, frame_info_ptr frame)
{
- return get_value_at (type, addr, 1);
+ return get_value_at (type, addr, frame, 1);
}
void
diff --git a/gdb/value.c b/gdb/value.c
index 7b4df338304..253ed3d596d 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -3438,12 +3438,14 @@ value_from_contents_and_address_unresolved (struct type *type,
struct value *
value_from_contents_and_address (struct type *type,
const gdb_byte *valaddr,
- CORE_ADDR address)
+ CORE_ADDR address,
+ frame_info_ptr frame)
{
gdb::array_view<const gdb_byte> view;
if (valaddr != nullptr)
view = gdb::make_array_view (valaddr, type->length ());
- struct type *resolved_type = resolve_dynamic_type (type, view, address);
+ struct type *resolved_type = resolve_dynamic_type (type, view, address,
+ &frame);
struct type *resolved_type_no_typedef = check_typedef (resolved_type);
struct value *v;
diff --git a/gdb/value.h b/gdb/value.h
index d83c4ab3674..02d66a80ef8 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -1077,7 +1077,13 @@ extern struct value *value_from_component (struct value *, struct type *,
extern struct value *value_at (struct type *type, CORE_ADDR addr);
-extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr);
+
+/* Return a new value given a type and an address. The new value is
+ lazy. If FRAME is given, it is used when resolving dynamic
+ properties. */
+
+extern struct value *value_at_lazy (struct type *type, CORE_ADDR addr,
+ frame_info_ptr frame = nullptr);
/* Like value_at, but ensures that the result is marked not_lval.
This can be important if the memory is "volatile". */
@@ -1085,9 +1091,9 @@ extern struct value *value_at_non_lval (struct type *type, CORE_ADDR addr);
extern struct value *value_from_contents_and_address_unresolved
(struct type *, const gdb_byte *, CORE_ADDR);
-extern struct value *value_from_contents_and_address (struct type *,
- const gdb_byte *,
- CORE_ADDR);
+extern struct value *value_from_contents_and_address
+ (struct type *, const gdb_byte *, CORE_ADDR,
+ frame_info_ptr frame = nullptr);
extern struct value *value_from_contents (struct type *, const gdb_byte *);
extern struct value *default_value_from_register (struct gdbarch *gdbarch,
--
2.39.1
^ permalink raw reply [flat|nested] 5+ messages in thread