* [PATCH] Turn value_field into a method
@ 2026-02-06 18:40 Tom Tromey
2026-02-06 18:55 ` Simon Marchi
0 siblings, 1 reply; 2+ messages in thread
From: Tom Tromey @ 2026-02-06 18:40 UTC (permalink / raw)
To: gdb-patches; +Cc: Tom Tromey
This changes value_field to be a method of struct value. This was
largely written by script.
---
gdb/ada-tasks.c | 54 ++++++++++++++++++----------------------------
gdb/ada-valprint.c | 6 +++---
gdb/ada-varobj.c | 2 +-
gdb/f-valprint.c | 2 +-
gdb/gnu-v2-abi.c | 8 +++----
gdb/gnu-v3-abi.c | 16 ++++++--------
gdb/rust-lang.c | 16 +++++++-------
gdb/value.c | 10 ---------
gdb/value.h | 10 +++++++--
9 files changed, 53 insertions(+), 71 deletions(-)
diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index 25da78f53dd..798d9c4cb32 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -477,15 +477,15 @@ read_fat_string_value (char *dest, struct value *val, int max_len)
/* Get the size of the task image by checking the value of the bounds.
The lower bound is always 1, so we only need to read the upper bound. */
- bounds_val = value_ind (value_field (val, bounds_fieldno));
- len = value_as_long (value_field (bounds_val, upper_bound_fieldno));
+ bounds_val = value_ind (val->field (bounds_fieldno));
+ len = value_as_long (bounds_val->field (upper_bound_fieldno));
/* Make sure that we do not read more than max_len characters... */
if (len > max_len)
len = max_len;
/* Extract LEN characters from the fat string. */
- array_val = value_ind (value_field (val, array_fieldno));
+ array_val = value_ind (val->field (array_fieldno));
read_memory (array_val->address (), (gdb_byte *) dest, len);
/* Add the NUL character to close the string. */
@@ -640,13 +640,11 @@ ptid_from_atcb_common (struct value *common_value)
const struct ada_tasks_pspace_data *pspace_data
= get_ada_tasks_pspace_data (current_program_space);
- ll_value = value_field (common_value, pspace_data->atcb_fieldno.ll);
+ ll_value = common_value->field (pspace_data->atcb_fieldno.ll);
if (pspace_data->atcb_fieldno.ll_lwp >= 0)
- lwp = value_as_address (value_field (ll_value,
- pspace_data->atcb_fieldno.ll_lwp));
- thread = value_as_long (value_field (ll_value,
- pspace_data->atcb_fieldno.ll_thread));
+ lwp = value_as_address (ll_value->field (pspace_data->atcb_fieldno.ll_lwp));
+ thread = value_as_long (ll_value->field (pspace_data->atcb_fieldno.ll_thread));
ptid = target_get_ada_task_ptid (lwp, thread);
@@ -684,7 +682,7 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
tcb_value = value_from_contents_and_address (pspace_data->atcb_type,
NULL, task_id);
- common_value = value_field (tcb_value, pspace_data->atcb_fieldno.common);
+ common_value = tcb_value->field (pspace_data->atcb_fieldno.common);
/* Fill in the task_id. */
@@ -709,8 +707,7 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
{
if (pspace_data->atcb_fieldno.image >= 0)
read_fat_string_value (task_info->name,
- value_field (common_value,
- pspace_data->atcb_fieldno.image),
+ common_value->field (pspace_data->atcb_fieldno.image),
sizeof (task_info->name) - 1);
else
{
@@ -741,31 +738,26 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
else
{
int len = value_as_long
- (value_field (common_value,
- pspace_data->atcb_fieldno.image_len));
+ (common_value->field (pspace_data->atcb_fieldno.image_len));
value_as_string (task_info->name,
- value_field (common_value,
- pspace_data->atcb_fieldno.image),
+ common_value->field (pspace_data->atcb_fieldno.image),
len);
}
/* Compute the task state and priority. */
task_info->state =
- value_as_long (value_field (common_value,
- pspace_data->atcb_fieldno.state));
+ value_as_long (common_value->field (pspace_data->atcb_fieldno.state));
task_info->priority =
- value_as_long (value_field (common_value,
- pspace_data->atcb_fieldno.priority));
+ value_as_long (common_value->field (pspace_data->atcb_fieldno.priority));
/* If the ATCB contains some information about the parent task,
then compute it as well. Otherwise, zero. */
if (pspace_data->atcb_fieldno.parent >= 0)
task_info->parent =
- value_as_address (value_field (common_value,
- pspace_data->atcb_fieldno.parent));
+ value_as_address (common_value->field (pspace_data->atcb_fieldno.parent));
/* If the task is in an entry call waiting for another task,
then determine which task it is. */
@@ -778,10 +770,10 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
entry of another task; then the Task_Id of the called task is
in My_ATCB.Entry_Calls (My_ATCB.ATC_Nesting_Level).Called_Task. */
atc_nesting_level_value =
- value_field (tcb_value, pspace_data->atcb_fieldno.atc_nesting_level);
+ tcb_value->field (pspace_data->atcb_fieldno.atc_nesting_level);
entry_calls_value =
ada_coerce_to_simple_array_ptr
- (value_field (tcb_value, pspace_data->atcb_fieldno.entry_calls));
+ (tcb_value->field (pspace_data->atcb_fieldno.entry_calls));
entry_calls_value_element =
value_subscript (entry_calls_value,
value_as_long (atc_nesting_level_value));
@@ -789,8 +781,7 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
ada_get_field_index (entry_calls_value_element->type (),
"called_task", 0);
task_info->called_task =
- value_as_address (value_field (entry_calls_value_element,
- called_task_fieldno));
+ value_as_address (entry_calls_value_element->field (called_task_fieldno));
}
/* If the ATCB contains some information about RV callers, then
@@ -801,8 +792,7 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
/* Get the ID of the caller task from Common_ATCB.Call.all.Self.
If Common_ATCB.Call is null, then there is no caller. */
const CORE_ADDR call =
- value_as_address (value_field (common_value,
- pspace_data->atcb_fieldno.call));
+ value_as_address (common_value->field (pspace_data->atcb_fieldno.call));
struct value *call_val;
if (call != 0)
@@ -812,14 +802,13 @@ read_atcb (CORE_ADDR task_id, struct ada_task_info *task_info)
NULL, call);
task_info->caller_task =
value_as_address
- (value_field (call_val, pspace_data->atcb_fieldno.call_self));
+ (call_val->field (pspace_data->atcb_fieldno.call_self));
}
}
task_info->base_cpu
= (pspace_data->cpu_id_offset
- + value_as_long (value_field (common_value,
- pspace_data->atcb_fieldno.base_cpu)));
+ + value_as_long (common_value->field (pspace_data->atcb_fieldno.base_cpu)));
/* And finally, compute the task ptid. Note that there is not point
in computing it if the task is no longer alive, in which case
@@ -899,10 +888,9 @@ read_known_tasks_list (struct ada_tasks_inferior_data *data)
/* Read the chain. */
tcb_value = value_from_contents_and_address (pspace_data->atcb_type,
NULL, task_id);
- common_value = value_field (tcb_value, pspace_data->atcb_fieldno.common);
+ common_value = tcb_value->field (pspace_data->atcb_fieldno.common);
task_id = value_as_address
- (value_field (common_value,
- pspace_data->atcb_fieldno.activation_link));
+ (common_value->field (pspace_data->atcb_fieldno.activation_link));
}
return true;
diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c
index 66b083ef5ed..639f4549f90 100644
--- a/gdb/ada-valprint.c
+++ b/gdb/ada-valprint.c
@@ -411,8 +411,8 @@ print_variant_part (struct value *value, int field_num,
if (which < 0)
return 0;
- struct value *variant_field = value_field (value, field_num);
- struct value *active_component = value_field (variant_field, which);
+ struct value *variant_field = value->field (field_num);
+ struct value *active_component = variant_field->field (which);
return print_field_values (active_component, outer_value, stream, recurse,
options, comma_needed, language);
}
@@ -520,7 +520,7 @@ print_field_values (struct value *value, struct value *outer_value,
opts.deref_ref = false;
- struct value *v = value_field (value, i);
+ struct value *v = value->field (i);
common_val_print (v, stream, recurse + 1, &opts, language);
}
annotate_field_end ();
diff --git a/gdb/ada-varobj.c b/gdb/ada-varobj.c
index 574429348a7..453453bc4ee 100644
--- a/gdb/ada-varobj.c
+++ b/gdb/ada-varobj.c
@@ -100,7 +100,7 @@ ada_varobj_struct_elt (struct value *parent_value,
if (parent_value)
{
- value = value_field (parent_value, fieldno);
+ value = parent_value->field (fieldno);
type = value->type ();
}
else
diff --git a/gdb/f-valprint.c b/gdb/f-valprint.c
index e91ae972e3e..c66e90c0402 100644
--- a/gdb/f-valprint.c
+++ b/gdb/f-valprint.c
@@ -559,7 +559,7 @@ f_language::value_print_inner (struct value *val, struct ui_file *stream,
field = value_of_variable (sym.symbol, sym.block);
}
else
- field = value_field (val, index);
+ field = val->field (index);
if (printed_field > 0)
gdb_puts (", ", stream);
diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index 55b01d982df..e5dcbd69c0b 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -157,7 +157,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
{
/* Move the `this' pointer according to the virtual function table. */
arg1->set_offset (arg1->offset ()
- + value_as_long (value_field (entry, 0)));
+ + value_as_long (entry->field (0)));
if (!arg1->lazy ())
{
@@ -165,7 +165,7 @@ gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
arg1->fetch_lazy ();
}
- vfn = value_field (entry, 2);
+ vfn = entry->field (2);
}
else if (entry_type->code () == TYPE_CODE_PTR)
vfn = entry;
@@ -231,10 +231,10 @@ gnuv2_value_rtti_type (struct value *v, int *full, LONGEST *top, int *using_enc)
/* We can't use value_ind here, because it would want to use RTTI, and
we'd waste a bunch of time figuring out we already know the type.
Besides, we don't care about the type, just the actual pointer. */
- if (value_field (v, known_type_vptr_fieldno)->address () == 0)
+ if (v->field (known_type_vptr_fieldno)->address () == 0)
return NULL;
- vtbl = value_as_address (value_field (v, known_type_vptr_fieldno));
+ vtbl = value_as_address (v->field (known_type_vptr_fieldno));
/* Try to find a symbol that is the vtable. */
bound_minimal_symbol minsym = lookup_minimal_symbol_by_pc (vtbl);
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index 4a4ed899a06..3d519eaa971 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -376,7 +376,7 @@ gnuv3_rtti_type (struct value *value,
/* Get the offset from VALUE to the top of the complete object.
NOTE: this is the reverse of the meaning of *TOP_P. */
offset_to_top
- = value_as_long (value_field (vtable, vtable_field_offset_to_top));
+ = value_as_long (vtable->field (vtable_field_offset_to_top));
if (full_p)
*full_p = (- offset_to_top == value->embedded_offset ()
@@ -402,7 +402,7 @@ gnuv3_get_virtual_fn (struct gdbarch *gdbarch, struct value *container,
gdb_assert (vtable != NULL);
/* Fetch the appropriate function pointer from the vtable. */
- vfn = value_subscript (value_field (vtable, vtable_field_virtual_functions),
+ vfn = value_subscript (vtable->field (vtable_field_virtual_functions),
vtable_index);
/* If this architecture uses function descriptors directly in the vtable,
@@ -515,7 +515,7 @@ gnuv3_baseclass_offset (struct type *type, int index,
vtable = gnuv3_get_vtable (gdbarch, type, address + embedded_offset);
gdb_assert (vtable != NULL);
- vbase_array = value_field (vtable, vtable_field_vcall_and_vbase_offsets);
+ vbase_array = vtable->field (vtable_field_vcall_and_vbase_offsets);
base_offset = value_as_long (value_subscript (vbase_array, cur_base_offset));
return base_offset;
}
@@ -865,7 +865,7 @@ compute_vtable_size (vtable_hash_t &offset_hash, struct value *value)
/* Recurse into base classes. */
for (i = 0; i < TYPE_N_BASECLASSES (type); ++i)
- compute_vtable_size (offset_hash, value_field (value, i));
+ compute_vtable_size (offset_hash, value->field (i));
}
/* Helper for gnuv3_print_vtable that prints a single vtable. */
@@ -883,8 +883,7 @@ print_one_vtable (struct gdbarch *gdbarch, struct value *value,
vtable = gnuv3_get_vtable (gdbarch, type,
value->address ()
+ value->embedded_offset ());
- vt_addr = value_field (vtable,
- vtable_field_virtual_functions)->address ();
+ vt_addr = vtable->field (vtable_field_virtual_functions)->address ();
gdb_printf (_("vtable for '%s' @ %s (subobject @ %s):\n"),
TYPE_SAFE_NAME (type),
@@ -901,8 +900,7 @@ print_one_vtable (struct gdbarch *gdbarch, struct value *value,
gdb_printf ("[%d]: ", i);
- vfn = value_subscript (value_field (vtable,
- vtable_field_virtual_functions),
+ vfn = value_subscript (vtable->field (vtable_field_virtual_functions),
i);
if (gdbarch_vtable_function_descriptors (gdbarch))
@@ -1119,7 +1117,7 @@ gnuv3_get_typeid (struct value *value)
if (vtable == NULL)
error (_("cannot find typeinfo for object of type '%s'"),
name);
- typeinfo_value = value_field (vtable, vtable_field_type_info);
+ typeinfo_value = vtable->field (vtable_field_type_info);
result = value_ind (value_cast (make_pointer_type (typeinfo_type),
typeinfo_value));
}
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index 1695fd73344..9f5c01afda4 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -260,7 +260,7 @@ rust_get_trait_object_pointer (struct value *value)
return NULL;
}
- CORE_ADDR vtable = value_as_address (value_field (value, vtable_field));
+ CORE_ADDR vtable = value_as_address (value->field (vtable_field));
struct symbol *symbol = find_symbol_at_address (vtable);
if (symbol == NULL || symbol->subclass != SYMBOL_RUST_VTABLE)
return NULL;
@@ -268,7 +268,7 @@ rust_get_trait_object_pointer (struct value *value)
struct rust_vtable_symbol *vtable_sym
= static_cast<struct rust_vtable_symbol *> (symbol);
struct type *pointer_type = lookup_pointer_type (vtable_sym->concrete_type);
- return value_cast (pointer_type, value_field (value, 1 - vtable_field));
+ return value_cast (pointer_type, value->field (1 - vtable_field));
}
/* Find and possibly rewrite the unsized part of a slice-like type.
@@ -620,7 +620,7 @@ rust_language::val_print_struct
gdb_puts (": ", stream);
}
- common_val_print (value_field (val, i), stream, recurse + 1, &opts,
+ common_val_print (val->field (i), stream, recurse + 1, &opts,
this);
}
@@ -700,7 +700,7 @@ rust_language::print_enum (struct value *val, struct ui_file *stream,
styled_string (variable_name_style.style (),
variant_type->field (j).name ()));
- common_val_print (value_field (val, j), stream, recurse + 1, &opts,
+ common_val_print (val->field (j), stream, recurse + 1, &opts,
this);
}
@@ -1326,7 +1326,7 @@ rust_compute_range (struct type *type, struct value *range,
if (strcmp (type->field (0).name (), "start") == 0)
{
*kind = RANGE_HIGH_BOUND_DEFAULT;
- *low = value_as_long (value_field (range, 0));
+ *low = value_as_long (range->field (0));
++i;
}
if (type->num_fields () > i
@@ -1334,7 +1334,7 @@ rust_compute_range (struct type *type, struct value *range,
{
*kind = (*kind == (RANGE_LOW_BOUND_DEFAULT | RANGE_HIGH_BOUND_DEFAULT)
? RANGE_LOW_BOUND_DEFAULT : RANGE_STANDARD);
- *high = value_as_long (value_field (range, i));
+ *high = value_as_long (range->field (i));
if (rust_inclusive_range_type_p (type))
++*high;
@@ -1478,8 +1478,8 @@ rust_subscript_operation::subscript (struct expression *exp,
addr = value_as_long (addrval);
tem = value_at_lazy (slice, addr);
- value_assign (value_field (tem, 0), value_addr (result));
- value_assign (value_field (tem, 1),
+ value_assign (tem->field (0), value_addr (result));
+ value_assign (tem->field (1),
value_from_longest (usize, high - low));
result = value_at_lazy (slice, addr);
diff --git a/gdb/value.c b/gdb/value.c
index a52d4a6742c..2d90780f57a 100644
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -3138,16 +3138,6 @@ value::primitive_field (LONGEST offset, int fieldno, struct type *arg_type)
return v;
}
-/* Given a value ARG1 of a struct or union type,
- extract and return the value of one of its (non-static) fields.
- FIELDNO says which field. */
-
-struct value *
-value_field (struct value *arg1, int fieldno)
-{
- return arg1->primitive_field (0, fieldno, arg1->type ());
-}
-
/* Return a non-virtual function as a value.
F is the list of member functions which contains the desired method.
J is an index into F which provides the desired method.
diff --git a/gdb/value.h b/gdb/value.h
index 1ef3acd6054..201db773a84 100644
--- a/gdb/value.h
+++ b/gdb/value.h
@@ -626,6 +626,14 @@ struct value
struct value *primitive_field (LONGEST offset, int fieldno,
struct type *arg_type);
+ /* Given that this value is of a struct or union type, extract and
+ return the value of one of its (non-static) fields. FIELDNO says
+ which field. */
+ value *field (int fieldno)
+ {
+ return primitive_field (0, fieldno, type ());
+ }
+
/* Create a new value by extracting it from this value. TYPE is the
type of the new value. BIT_OFFSET and BIT_LENGTH describe the
offset and field width of the value to extract from this value --
@@ -1331,8 +1339,6 @@ extern int find_overload_match (gdb::array_view<value *> args,
int *staticp, const int no_adl,
enum noside noside);
-extern struct value *value_field (struct value *arg1, int fieldno);
-
extern struct type *value_rtti_indirect_type (struct value *, int *, LONGEST *,
int *);
--
2.49.0
^ permalink raw reply [flat|nested] 2+ messages in thread* Re: [PATCH] Turn value_field into a method
2026-02-06 18:40 [PATCH] Turn value_field into a method Tom Tromey
@ 2026-02-06 18:55 ` Simon Marchi
0 siblings, 0 replies; 2+ messages in thread
From: Simon Marchi @ 2026-02-06 18:55 UTC (permalink / raw)
To: Tom Tromey, gdb-patches
On 2026-02-06 13:40, Tom Tromey wrote:
> diff --git a/gdb/value.h b/gdb/value.h
> index 1ef3acd6054..201db773a84 100644
> --- a/gdb/value.h
> +++ b/gdb/value.h
> @@ -626,6 +626,14 @@ struct value
> struct value *primitive_field (LONGEST offset, int fieldno,
> struct type *arg_type);
>
> + /* Given that this value is of a struct or union type, extract and
> + return the value of one of its (non-static) fields. FIELDNO says
> + which field. */
For future work: that comment makes me think it would be nice to have an
assert (probably in value::primitive_field) to check that the type is
indeed a struct or union. If calling with a non-struct/non-union type,
this assert in type::field would probably trigger:
gdb_assert (idx >= 0 && idx < num_fields ());
But it would be nice to check the precondition in primitive_field too,
it would be clearer.
Approved-By: Simon Marchi <simon.marchi@efficios.com>
Simon
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2026-02-06 18:55 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-02-06 18:40 [PATCH] Turn value_field into a method Tom Tromey
2026-02-06 18:55 ` Simon Marchi
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox