* [PATCH 0/3] Handle dynamic properties and static link
@ 2023-03-09 17:50 Tom Tromey
2023-03-09 17:50 ` [PATCH 1/3] Add frame parameter to resolve_dynamic_type Tom Tromey
` (3 more replies)
0 siblings, 4 replies; 5+ messages in thread
From: Tom Tromey @ 2023-03-09 17:50 UTC (permalink / raw)
To: gdb-patches
Ada uses static links and dynamic properties more than most other
languages. A user found a bug when the two are combined, and this
series fixes the problem.
Regression tested on x86-64 Fedora 36.
Tom
---
Tom Tromey (3):
Add frame parameter to resolve_dynamic_type
Pass a frame to value_at_lazy and value_from_contents_and_address
Use the correct frame when evaluating a dynamic property
gdb/dwarf2/expr.c | 4 +-
gdb/gdbtypes.c | 71 ++++++++++++++++++------------
gdb/gdbtypes.h | 6 ++-
gdb/testsuite/gdb.ada/static-link.exp | 33 ++++++++++++++
gdb/testsuite/gdb.ada/static-link/pck.ads | 18 ++++++++
gdb/testsuite/gdb.ada/static-link/prog.adb | 35 +++++++++++++++
gdb/valops.c | 11 ++---
gdb/value.c | 6 ++-
gdb/value.h | 14 ++++--
9 files changed, 156 insertions(+), 42 deletions(-)
---
base-commit: 093b56776fcf31ecc9342382341c1455fd397b16
change-id: 20230309-submit-static-link-fix-bcf714c48091
Best regards,
--
Tom Tromey <tromey@adacore.com>
^ permalink raw reply [flat|nested] 5+ messages in thread
* [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
* [PATCH 3/3] Use the correct frame when evaluating a dynamic property
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 ` [PATCH 2/3] Pass a frame to value_at_lazy and value_from_contents_and_address Tom Tromey
@ 2023-03-09 17:50 ` 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
The test case in this patch shows an unusual situation: an Ada array
has a dynamic bound, but the bound comes from a frame that's referred
to by the static link. This frame is correctly found when evaluating
the array variable itself, but is lost when evaluating the array's
bounds.
This patch fixes the problem by passing this frame through to
value_at_lazy in the DWARF expression evaluator.
---
gdb/dwarf2/expr.c | 4 ++--
gdb/testsuite/gdb.ada/static-link.exp | 33 ++++++++++++++++++++++++++++
gdb/testsuite/gdb.ada/static-link/pck.ads | 18 +++++++++++++++
gdb/testsuite/gdb.ada/static-link/prog.adb | 35 ++++++++++++++++++++++++++++++
4 files changed, 88 insertions(+), 2 deletions(-)
diff --git a/gdb/dwarf2/expr.c b/gdb/dwarf2/expr.c
index 2b41372be8a..fd83ba29a90 100644
--- a/gdb/dwarf2/expr.c
+++ b/gdb/dwarf2/expr.c
@@ -1002,8 +1002,8 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type,
}
address = value_as_address (value_from_pointer (ptr_type, address));
- retval = value_at_lazy (subobj_type,
- address + subobj_offset);
+ retval = value_at_lazy (subobj_type, address + subobj_offset,
+ m_frame);
if (in_stack_memory)
retval->set_stack (true);
}
diff --git a/gdb/testsuite/gdb.ada/static-link.exp b/gdb/testsuite/gdb.ada/static-link.exp
new file mode 100644
index 00000000000..86f2fb5076b
--- /dev/null
+++ b/gdb/testsuite/gdb.ada/static-link.exp
@@ -0,0 +1,33 @@
+# Copyright 2023 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+load_lib "ada.exp"
+
+require allow_ada_tests
+
+standard_ada_testfile prog
+
+if {[gdb_compile_ada "${srcfile}" "${binfile}" executable {debug}] != ""} {
+ return -1
+}
+
+clean_restart ${testfile}
+
+set bp_location [gdb_get_line_number "STOP" ${testdir}/prog.adb]
+if {![runto "prog.adb:$bp_location"]} {
+ return -1
+}
+
+gdb_test "ptype value" [string_to_regexp "type = array (1 .. 3) of integer"]
diff --git a/gdb/testsuite/gdb.ada/static-link/pck.ads b/gdb/testsuite/gdb.ada/static-link/pck.ads
new file mode 100644
index 00000000000..a37f7bb0a10
--- /dev/null
+++ b/gdb/testsuite/gdb.ada/static-link/pck.ads
@@ -0,0 +1,18 @@
+-- Copyright 2023 Free Software Foundation, Inc.
+--
+-- This program is free software; you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation; either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+package Pck is
+ Some_Value : Integer := 3;
+end Pck;
diff --git a/gdb/testsuite/gdb.ada/static-link/prog.adb b/gdb/testsuite/gdb.ada/static-link/prog.adb
new file mode 100644
index 00000000000..a14817b7440
--- /dev/null
+++ b/gdb/testsuite/gdb.ada/static-link/prog.adb
@@ -0,0 +1,35 @@
+-- Copyright 2023 Free Software Foundation, Inc.
+--
+-- This program is free software; you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation; either version 3 of the License, or
+-- (at your option) any later version.
+--
+-- This program is distributed in the hope that it will be useful,
+-- but WITHOUT ANY WARRANTY; without even the implied warranty of
+-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+-- GNU General Public License for more details.
+--
+-- You should have received a copy of the GNU General Public License
+-- along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+with Pck; use Pck;
+
+procedure Prog is
+
+ Upper : Integer := Some_Value;
+ Value : array (1 .. Upper) of Integer := (23, 24, 25);
+
+ procedure Inner_Most is
+ begin
+ null; -- STOP
+ end;
+
+ procedure Intermediate is
+ begin
+ Inner_Most;
+ end;
+
+begin
+ Intermediate;
+end Prog;
--
2.39.1
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH 0/3] Handle dynamic properties and static link
2023-03-09 17:50 [PATCH 0/3] Handle dynamic properties and static link Tom Tromey
` (2 preceding siblings ...)
2023-03-09 17:50 ` [PATCH 3/3] Use the correct frame when evaluating a dynamic property Tom Tromey
@ 2023-03-29 16:16 ` Tom Tromey
3 siblings, 0 replies; 5+ messages in thread
From: Tom Tromey @ 2023-03-29 16:16 UTC (permalink / raw)
To: Tom Tromey via Gdb-patches; +Cc: Tom Tromey
>>>>> "Tom" == Tom Tromey via Gdb-patches <gdb-patches@sourceware.org> writes:
Tom> Ada uses static links and dynamic properties more than most other
Tom> languages. A user found a bug when the two are combined, and this
Tom> series fixes the problem.
Tom> Regression tested on x86-64 Fedora 36.
I'm checking this in now.
Tom
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2023-03-29 16:16 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
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 ` [PATCH 2/3] Pass a frame to value_at_lazy and value_from_contents_and_address 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
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).