FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Turn value_address and set_value_address functions into methods

Browse source 
This changes the value_address and set_value_address functions to be
methods of value.

Approved-By: Simon Marchi <simon.marchi@efficios.com>
This commit is contained in:
Tom Tromey 2023-01-31 12:27:30 -07:00
parent 8e5b19ad99
commit 9feb2d07de
45 changed files with 166 additions and 167 deletions
Download patch file Download diff file Expand all files Collapse all files

34
gdb/ada-lang.c
View file

@ -571,7 +571,7 @@ coerce_unspec_val_to_type (struct value *val, struct type *type)
result->set_bitsize (val->bitsize ()); result->set_bitsize (val->bitsize ());
result->set_bitpos (val->bitpos ()); result->set_bitpos (val->bitpos ());
if (VALUE_LVAL (result) == lval_memory) if (VALUE_LVAL (result) == lval_memory)
set_value_address (result, value_address (val)); result->set_address (val->address ());
return result; return result;
} }
} }
@ -1764,7 +1764,7 @@ thin_data_pntr (struct value *val)
if (type->code () == TYPE_CODE_PTR) if (type->code () == TYPE_CODE_PTR)
return value_cast (data_type, value_copy (val)); return value_cast (data_type, value_copy (val));
else else
return value_from_longest (data_type, value_address (val)); return value_from_longest (data_type, val->address ());
} }
/* True iff TYPE indicates a "thick" array pointer type. */ /* True iff TYPE indicates a "thick" array pointer type. */
@ -1830,7 +1830,7 @@ desc_bounds (struct value *arr)
if (type->code () == TYPE_CODE_PTR) if (type->code () == TYPE_CODE_PTR)
addr = value_as_long (arr); addr = value_as_long (arr);
else else
addr = value_address (arr); addr = arr->address ();
return return
value_from_longest (lookup_pointer_type (bounds_type), value_from_longest (lookup_pointer_type (bounds_type),
@ -2517,7 +2517,7 @@ decode_constrained_packed_array (struct value *arr)
we further resolve the array bounds here and then update the we further resolve the array bounds here and then update the
sizes. */ sizes. */
const gdb_byte *valaddr = value_contents_for_printing (arr).data (); const gdb_byte *valaddr = value_contents_for_printing (arr).data ();
CORE_ADDR address = value_address (arr); CORE_ADDR address = arr->address ();
gdb::array_view<const gdb_byte> view gdb::array_view<const gdb_byte> view
= gdb::make_array_view (valaddr, type->length ()); = gdb::make_array_view (valaddr, type->length ());
type = resolve_dynamic_type (type, view, address); type = resolve_dynamic_type (type, view, address);
@ -2815,9 +2815,9 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
int src_len = (bit_size + bit_offset + HOST_CHAR_BIT - 1) / 8; int src_len = (bit_size + bit_offset + HOST_CHAR_BIT - 1) / 8;
gdb_byte *buf; gdb_byte *buf;
v = value_at (type, value_address (obj) + offset); v = value_at (type, obj->address () + offset);
buf = (gdb_byte *) alloca (src_len); buf = (gdb_byte *) alloca (src_len);
read_memory (value_address (v), buf, src_len); read_memory (v->address (), buf, src_len);
src = buf; src = buf;
} }
else else
@ -2901,7 +2901,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
int from_size; int from_size;
gdb_byte *buffer = (gdb_byte *) alloca (len); gdb_byte *buffer = (gdb_byte *) alloca (len);
struct value *val; struct value *val;
CORE_ADDR to_addr = value_address (toval); CORE_ADDR to_addr = toval->address ();
if (type->code () == TYPE_CODE_FLT) if (type->code () == TYPE_CODE_FLT)
fromval = value_cast (type, fromval); fromval = value_cast (type, fromval);
@ -2949,7 +2949,7 @@ value_assign_to_component (struct value *container, struct value *component,
struct value *val) struct value *val)
{ {
LONGEST offset_in_container = LONGEST offset_in_container =
(LONGEST) (value_address (component) - value_address (container)); (LONGEST) (component->address () - container->address ());
int bit_offset_in_container = int bit_offset_in_container =
component->bitpos () - container->bitpos (); component->bitpos () - container->bitpos ();
int bits; int bits;
@ -4357,7 +4357,7 @@ ensure_lval (struct value *val)
value_as_long (value_allocate_space_in_inferior (len)); value_as_long (value_allocate_space_in_inferior (len));
VALUE_LVAL (val) = lval_memory; VALUE_LVAL (val) = lval_memory;
set_value_address (val, addr); val->set_address (addr);
write_memory (addr, value_contents (val).data (), len); write_memory (addr, value_contents (val).data (), len);
} }
@ -4425,9 +4425,9 @@ ada_value_struct_elt (struct value *arg, const char *name, int no_err)
CORE_ADDR address; CORE_ADDR address;
if (t->code () == TYPE_CODE_PTR) if (t->code () == TYPE_CODE_PTR)
address = value_address (ada_value_ind (arg)); address = ada_value_ind (arg)->address ();
else else
address = value_address (ada_coerce_ref (arg)); address = ada_coerce_ref (arg)->address ();
/* Check to see if this is a tagged type. We also need to handle /* Check to see if this is a tagged type. We also need to handle
the case where the type is a reference to a tagged type, but the case where the type is a reference to a tagged type, but
@ -4566,7 +4566,7 @@ value_pointer (struct value *value, struct type *type)
gdb_byte *buf = (gdb_byte *) alloca (len); gdb_byte *buf = (gdb_byte *) alloca (len);
CORE_ADDR addr; CORE_ADDR addr;
addr = value_address (value); addr = value->address ();
gdbarch_address_to_pointer (type->arch (), type, buf, addr); gdbarch_address_to_pointer (type->arch (), type, buf, addr);
addr = extract_unsigned_integer (buf, len, type_byte_order (type)); addr = extract_unsigned_integer (buf, len, type_byte_order (type));
return addr; return addr;
@ -6510,7 +6510,7 @@ ada_tag_value_at_base_address (struct value *obj)
offset_to_top = -offset_to_top; offset_to_top = -offset_to_top;
} }
base_address = value_address (obj) + offset_to_top; base_address = obj->address () + offset_to_top;
tag = value_tag_from_contents_and_address (obj_type, NULL, base_address); tag = value_tag_from_contents_and_address (obj_type, NULL, base_address);
/* Make sure that we have a proper tag at the new address. /* Make sure that we have a proper tag at the new address.
@ -8591,7 +8591,7 @@ ada_to_fixed_type_1 (struct type *type, const gdb_byte *valaddr,
if (real_type != NULL) if (real_type != NULL)
return to_fixed_record_type return to_fixed_record_type
(real_type, NULL, (real_type, NULL,
value_address (ada_tag_value_at_base_address (obj)), NULL); ada_tag_value_at_base_address (obj)->address (), NULL);
} }
/* Check to see if there is a parallel ___XVZ variable. /* Check to see if there is a parallel ___XVZ variable.
@ -8860,7 +8860,7 @@ struct value *
ada_to_fixed_value (struct value *val) ada_to_fixed_value (struct value *val)
{ {
val = unwrap_value (val); val = unwrap_value (val);
val = ada_to_fixed_value_create (val->type (), value_address (val), val); val = ada_to_fixed_value_create (val->type (), val->address (), val);
return val; return val;
} }
@ -9225,7 +9225,7 @@ unwrap_value (struct value *val)
return return
coerce_unspec_val_to_type coerce_unspec_val_to_type
(val, ada_to_fixed_type (raw_real_type, 0, (val, ada_to_fixed_type (raw_real_type, 0,
value_address (val), val->address (),
NULL, 1)); NULL, 1));
} }
} }
@ -12033,7 +12033,7 @@ ada_exception_message_1 (void)
return NULL; return NULL;
gdb::unique_xmalloc_ptr<char> e_msg ((char *) xmalloc (e_msg_len + 1)); gdb::unique_xmalloc_ptr<char> e_msg ((char *) xmalloc (e_msg_len + 1));
read_memory (value_address (e_msg_val), (gdb_byte *) e_msg.get (), read_memory (e_msg_val->address (), (gdb_byte *) e_msg.get (),
e_msg_len); e_msg_len);
e_msg.get ()[e_msg_len] = '\0'; e_msg.get ()[e_msg_len] = '\0';

2
gdb/ada-tasks.c
View file

@ -484,7 +484,7 @@ read_fat_string_value (char *dest, struct value *val, int max_len)
/* Extract LEN characters from the fat string. */ /* Extract LEN characters from the fat string. */
array_val = value_ind (value_field (val, array_fieldno)); array_val = value_ind (value_field (val, array_fieldno));
read_memory (value_address (array_val), (gdb_byte *) dest, len); read_memory (array_val->address (), (gdb_byte *) dest, len);
/* Add the NUL character to close the string. */ /* Add the NUL character to close the string. */
dest[len] = '\0'; dest[len] = '\0';

2
gdb/ada-valprint.c
View file

@ -1022,7 +1022,7 @@ ada_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
struct type *saved_type = type; struct type *saved_type = type;
const gdb_byte *valaddr = value_contents_for_printing (val).data (); const gdb_byte *valaddr = value_contents_for_printing (val).data ();
CORE_ADDR address = value_address (val); CORE_ADDR address = val->address ();
gdb::array_view<const gdb_byte> view gdb::array_view<const gdb_byte> view
= gdb::make_array_view (valaddr, type->length ()); = gdb::make_array_view (valaddr, type->length ());
type = ada_check_typedef (resolve_dynamic_type (type, view, address)); type = ada_check_typedef (resolve_dynamic_type (type, view, address));

4
gdb/breakpoint.c
View file

@ -2108,7 +2108,7 @@ update_watchpoint (struct watchpoint *b, bool reparse)
bitsize = b->val_bitsize; bitsize = b->val_bitsize;
} }
addr = value_address (v); addr = v->address ();
if (bitsize != 0) if (bitsize != 0)
{ {
/* Skip the bytes that don't contain the bitfield. */ /* Skip the bytes that don't contain the bitfield. */
@ -10435,7 +10435,7 @@ can_use_hardware_watchpoint (const std::vector<value_ref_ptr> &vals)
|| (vtype->code () != TYPE_CODE_STRUCT || (vtype->code () != TYPE_CODE_STRUCT
&& vtype->code () != TYPE_CODE_ARRAY)) && vtype->code () != TYPE_CODE_ARRAY))
{ {
CORE_ADDR vaddr = value_address (v); CORE_ADDR vaddr = v->address ();
int len; int len;
int num_regs; int num_regs;

2
gdb/c-lang.c
View file

@ -331,7 +331,7 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
if (VALUE_LVAL (value) != lval_memory) if (VALUE_LVAL (value) != lval_memory)
error (_("Attempt to take address of value " error (_("Attempt to take address of value "
"not located in memory.")); "not located in memory."));
addr = value_address (value); addr = value->address ();
} }
else else
addr = value_as_address (value); addr = value_as_address (value);

2
gdb/c-valprint.c
View file

@ -236,7 +236,7 @@ c_value_print_array (struct value *val,
const struct value_print_options *options) const struct value_print_options *options)
{ {
struct type *type = check_typedef (val->type ()); struct type *type = check_typedef (val->type ());
CORE_ADDR address = value_address (val); CORE_ADDR address = val->address ();
const gdb_byte *valaddr = value_contents_for_printing (val).data (); const gdb_byte *valaddr = value_contents_for_printing (val).data ();
struct type *unresolved_elttype = type->target_type (); struct type *unresolved_elttype = type->target_type ();
struct type *elttype = check_typedef (unresolved_elttype); struct type *elttype = check_typedef (unresolved_elttype);

2
gdb/cli/cli-dump.c
View file

@ -232,7 +232,7 @@ dump_value_to_file (const char *cmd, const char *mode, const char *file_format)
if (VALUE_LVAL (val)) if (VALUE_LVAL (val))
{ {
vaddr = value_address (val); vaddr = val->address ();
} }
else else
{ {

2
gdb/compile/compile-c-symbols.c
View file

@ -162,7 +162,7 @@ convert_one_symbol (compile_c_instance *context,
sym.symbol->print_name ()); sym.symbol->print_name ());
kind = GCC_C_SYMBOL_VARIABLE; kind = GCC_C_SYMBOL_VARIABLE;
addr = value_address (val); addr = val->address ();
} }
break; break;

2
gdb/compile/compile-cplus-symbols.c
View file

@ -156,7 +156,7 @@ convert_one_symbol (compile_cplus_instance *instance,
sym.symbol->print_name ()); sym.symbol->print_name ());
kind = GCC_CP_SYMBOL_VARIABLE; kind = GCC_CP_SYMBOL_VARIABLE;
addr = value_address (val); addr = val->address ();
} }
break; break;

2
gdb/compile/compile-loc2c.c
View file

@ -654,7 +654,7 @@ do_compile_dwarf_expr_to_c (int indent, string_file *stream,
gdb_printf (stream, "%*s%s = %s;\n", gdb_printf (stream, "%*s%s = %s;\n",
indent, "", result_name, indent, "", result_name,
core_addr_to_string (value_address (val))); core_addr_to_string (val->address ()));
gdb_printf (stream, "%*s}\n", indent - 2, ""); gdb_printf (stream, "%*s}\n", indent - 2, "");
return; return;
} }

4
gdb/cp-valprint.c
View file

@ -390,7 +390,7 @@ cp_print_value (struct value *val, struct ui_file *stream,
struct type **dont_print_vb) struct type **dont_print_vb)
{ {
struct type *type = check_typedef (val->type ()); struct type *type = check_typedef (val->type ());
CORE_ADDR address = value_address (val); CORE_ADDR address = val->address ();
struct type **last_dont_print struct type **last_dont_print
= (struct type **) obstack_next_free (&dont_print_vb_obstack); = (struct type **) obstack_next_free (&dont_print_vb_obstack);
struct obstack tmp_obstack = dont_print_vb_obstack; struct obstack tmp_obstack = dont_print_vb_obstack;
@ -560,7 +560,7 @@ cp_print_static_field (struct type *type,
if (real_type->code () == TYPE_CODE_STRUCT) if (real_type->code () == TYPE_CODE_STRUCT)
{ {
CORE_ADDR *first_dont_print; CORE_ADDR *first_dont_print;
CORE_ADDR addr = value_address (val); CORE_ADDR addr = val->address ();
int i; int i;
first_dont_print first_dont_print

2
gdb/d-valprint.c
View file

@ -82,7 +82,7 @@ d_value_print_inner (struct value *val, struct ui_file *stream, int recurse,
{ {
case TYPE_CODE_STRUCT: case TYPE_CODE_STRUCT:
ret = dynamic_array_type (type, val->embedded_offset (), ret = dynamic_array_type (type, val->embedded_offset (),
value_address (val), val->address (),
stream, recurse, val, options); stream, recurse, val, options);
if (ret == 0) if (ret == 0)
break; break;

2
gdb/dwarf2/frame.c
View file

@ -236,7 +236,7 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
value *result_val = ctx.evaluate (exp, len, true, nullptr, this_frame); value *result_val = ctx.evaluate (exp, len, true, nullptr, this_frame);
if (VALUE_LVAL (result_val) == lval_memory) if (VALUE_LVAL (result_val) == lval_memory)
return value_address (result_val); return result_val->address ();
else else
return value_as_address (result_val); return value_as_address (result_val);
} }

8
gdb/dwarf2/loc.c
View file

@ -516,7 +516,7 @@ locexpr_get_frame_base (struct symbol *framefunc, frame_info_ptr frame)
dwarf2_evaluate_loc_desc returns a value representing a variable at dwarf2_evaluate_loc_desc returns a value representing a variable at
that address. The frame base address is thus this variable's that address. The frame base address is thus this variable's
address. */ address. */
return value_address (result); return result->address ();
} }
/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
@ -573,7 +573,7 @@ loclist_get_frame_base (struct symbol *framefunc, frame_info_ptr frame)
dwarf2_evaluate_loc_desc returns a value representing a variable at dwarf2_evaluate_loc_desc returns a value representing a variable at
that address. The frame base address is thus this variable's that address. The frame base address is thus this variable's
address. */ address. */
return value_address (result); return result->address ();
} }
/* Vector for inferior functions as represented by LOC_BLOCK, if the inferior /* Vector for inferior functions as represented by LOC_BLOCK, if the inferior
@ -685,7 +685,7 @@ call_site_target::iterate_over_addresses
dwarf_block->per_objfile); dwarf_block->per_objfile);
/* DW_AT_call_target is a DWARF expression, not a DWARF location. */ /* DW_AT_call_target is a DWARF expression, not a DWARF location. */
if (VALUE_LVAL (val) == lval_memory) if (VALUE_LVAL (val) == lval_memory)
callback (value_address (val)); callback (val->address ());
else else
callback (value_as_address (val)); callback (value_as_address (val));
} }
@ -1613,7 +1613,7 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,
return 0; return 0;
if (VALUE_LVAL (result) == lval_memory) if (VALUE_LVAL (result) == lval_memory)
*valp = value_address (result); *valp = result->address ();
else else
{ {
if (VALUE_LVAL (result) == not_lval) if (VALUE_LVAL (result) == not_lval)

4
gdb/elfread.c
View file

@ -924,7 +924,7 @@ elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
function = allocate_value (func_func_type); function = allocate_value (func_func_type);
VALUE_LVAL (function) = lval_memory; VALUE_LVAL (function) = lval_memory;
set_value_address (function, pc); function->set_address (pc);
/* STT_GNU_IFUNC resolver functions usually receive the HWCAP vector as /* STT_GNU_IFUNC resolver functions usually receive the HWCAP vector as
parameter. FUNCTION is the function entry address. ADDRESS may be a parameter. FUNCTION is the function entry address. ADDRESS may be a
@ -1035,7 +1035,7 @@ elf_gnu_ifunc_resolver_return_stop (code_breakpoint *b)
func_func = allocate_value (func_func_type); func_func = allocate_value (func_func_type);
VALUE_LVAL (func_func) = lval_memory; VALUE_LVAL (func_func) = lval_memory;
set_value_address (func_func, b->loc->related_address); func_func->set_address (b->loc->related_address);
value = allocate_value (value_type); value = allocate_value (value_type);
gdbarch_return_value_as_value (gdbarch, func_func, value_type, regcache, gdbarch_return_value_as_value (gdbarch, func_func, value_type, regcache,

6
gdb/eval.c
View file

@ -651,7 +651,7 @@ evaluate_subexp_do_call (expression *exp, enum noside noside,
{ {
if (ftype->is_gnu_ifunc ()) if (ftype->is_gnu_ifunc ())
{ {
CORE_ADDR address = value_address (callee); CORE_ADDR address = callee->address ();
type *resolved_type = find_gnu_ifunc_target_type (address); type *resolved_type = find_gnu_ifunc_target_type (address);
if (resolved_type != NULL) if (resolved_type != NULL)
@ -964,7 +964,7 @@ structop_base_operation::evaluate_funcall
``this'' pointer if necessary, so modify it to reflect any ``this'' pointer if necessary, so modify it to reflect any
``this'' changes. */ ``this'' changes. */
vals[0] = value_from_longest (lookup_pointer_type (temp->type ()), vals[0] = value_from_longest (lookup_pointer_type (temp->type ()),
value_address (temp) temp->address ()
+ temp->embedded_offset ()); + temp->embedded_offset ());
} }
@ -1136,7 +1136,7 @@ eval_op_func_static_var (struct type *expect_type, struct expression *exp,
enum noside noside, enum noside noside,
value *func, const char *var) value *func, const char *var)
{ {
CORE_ADDR addr = value_address (func); CORE_ADDR addr = func->address ();
const block *blk = block_for_pc (addr); const block *blk = block_for_pc (addr);
struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL); struct block_symbol sym = lookup_symbol (var, blk, VAR_DOMAIN, NULL);
if (sym.symbol == NULL) if (sym.symbol == NULL)

18
gdb/f-lang.c
View file

@ -408,7 +408,7 @@ fortran_associated (struct gdbarch *gdbarch, const language_defn *lang,
if (pointer_type->code () == TYPE_CODE_PTR) if (pointer_type->code () == TYPE_CODE_PTR)
pointer_addr = value_as_address (pointer); pointer_addr = value_as_address (pointer);
else else
pointer_addr = value_address (pointer); pointer_addr = pointer->address ();
/* The single argument case, is POINTER associated with anything? */ /* The single argument case, is POINTER associated with anything? */
if (target == nullptr) if (target == nullptr)
@ -470,7 +470,7 @@ fortran_associated (struct gdbarch *gdbarch, const language_defn *lang,
if (target_type->code () == TYPE_CODE_PTR) if (target_type->code () == TYPE_CODE_PTR)
target_addr = value_as_address (target); target_addr = value_as_address (target);
else else
target_addr = value_address (target); target_addr = target->address ();
/* Wrap the following checks inside a do { ... } while (false) loop so /* Wrap the following checks inside a do { ... } while (false) loop so
that we can use `break' to jump out of the loop. */ that we can use `break' to jump out of the loop. */
@ -1074,7 +1074,7 @@ eval_op_f_loc (struct type *expect_type, struct expression *exp,
else else
result_type = builtin_f_type (exp->gdbarch)->builtin_integer_s8; result_type = builtin_f_type (exp->gdbarch)->builtin_integer_s8;
LONGEST result_value = value_address (arg1); LONGEST result_value = arg1->address ();
return value_from_longest (result_type, result_value); return value_from_longest (result_type, result_value);
} }
@ -1410,7 +1410,7 @@ fortran_undetermined::value_subarray (value *array,
debug_printf (" |-> Total offset: %s\n", debug_printf (" |-> Total offset: %s\n",
plongest (total_offset)); plongest (total_offset));
debug_printf (" |-> Base address: %s\n", debug_printf (" |-> Base address: %s\n",
core_addr_to_string (value_address (array))); core_addr_to_string (array->address ()));
debug_printf (" '-> Contiguous = %s\n", debug_printf (" '-> Contiguous = %s\n",
(is_all_contiguous ? "Yes" : "No")); (is_all_contiguous ? "Yes" : "No"));
} }
@ -1446,13 +1446,13 @@ fortran_undetermined::value_subarray (value *array,
> check_typedef (array->type ())->length ())) > check_typedef (array->type ())->length ()))
{ {
fortran_array_walker<fortran_lazy_array_repacker_impl> p fortran_array_walker<fortran_lazy_array_repacker_impl> p
(array_slice_type, value_address (array) + total_offset, dest); (array_slice_type, array->address () + total_offset, dest);
p.walk (); p.walk ();
} }
else else
{ {
fortran_array_walker<fortran_array_repacker_impl> p fortran_array_walker<fortran_array_repacker_impl> p
(array_slice_type, value_address (array) + total_offset, (array_slice_type, array->address () + total_offset,
total_offset, array, dest); total_offset, array, dest);
p.walk (); p.walk ();
} }
@ -1470,11 +1470,11 @@ fortran_undetermined::value_subarray (value *array,
|| (total_offset + array_slice_type->length () || (total_offset + array_slice_type->length ()
> check_typedef (array->type ())->length ())) > check_typedef (array->type ())->length ()))
array = value_at_lazy (array_slice_type, array = value_at_lazy (array_slice_type,
value_address (array) + total_offset); array->address () + total_offset);
else else
array = value_from_contents_and_address array = value_from_contents_and_address
(array_slice_type, value_contents (array).data () + total_offset, (array_slice_type, value_contents (array).data () + total_offset,
value_address (array) + total_offset); array->address () + total_offset);
} }
else if (!array->lazy ()) else if (!array->lazy ())
array = value_from_component (array, array_slice_type, total_offset); array = value_from_component (array, array_slice_type, total_offset);
@ -1632,7 +1632,7 @@ fortran_structop_operation::evaluate (struct type *expect_type,
if (is_dynamic_type (elt_type)) if (is_dynamic_type (elt_type))
{ {
const gdb_byte *valaddr = value_contents_for_printing (elt).data (); const gdb_byte *valaddr = value_contents_for_printing (elt).data ();
CORE_ADDR address = value_address (elt); CORE_ADDR address = elt->address ();
gdb::array_view<const gdb_byte> view gdb::array_view<const gdb_byte> view
= gdb::make_array_view (valaddr, elt_type->length ()); = gdb::make_array_view (valaddr, elt_type->length ());
elt_type = resolve_dynamic_type (elt_type, view, address); elt_type = resolve_dynamic_type (elt_type, view, address);

2
gdb/f-valprint.c
View file

@ -457,7 +457,7 @@ f_language::value_print_inner (struct value *val, struct ui_file *stream,
CORE_ADDR addr; CORE_ADDR addr;
int index; int index;
const gdb_byte *valaddr = value_contents_for_printing (val).data (); const gdb_byte *valaddr = value_contents_for_printing (val).data ();
const CORE_ADDR address = value_address (val); const CORE_ADDR address = val->address ();
switch (type->code ()) switch (type->code ())
{ {

4
gdb/frame.c
View file

@ -1192,7 +1192,7 @@ frame_register_unwind (frame_info_ptr next_frame, int regnum,
*optimizedp = value_optimized_out (value); *optimizedp = value_optimized_out (value);
*unavailablep = !value_entirely_available (value); *unavailablep = !value_entirely_available (value);
*lvalp = VALUE_LVAL (value); *lvalp = VALUE_LVAL (value);
*addrp = value_address (value); *addrp = value->address ();
if (*lvalp == lval_register) if (*lvalp == lval_register)
*realnump = VALUE_REGNUM (value); *realnump = VALUE_REGNUM (value);
else else
@ -1302,7 +1302,7 @@ frame_unwind_register_value (frame_info_ptr next_frame, int regnum)
else if (VALUE_LVAL (value) == lval_memory) else if (VALUE_LVAL (value) == lval_memory)
gdb_printf (&debug_file, " address=%s", gdb_printf (&debug_file, " address=%s",
paddress (gdbarch, paddress (gdbarch,
value_address (value))); value->address ()));
else else
gdb_printf (&debug_file, " computed"); gdb_printf (&debug_file, " computed");

2
gdb/frv-tdep.c
View file

@ -1238,7 +1238,7 @@ frv_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION) if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
{ {
store_unsigned_integer (valbuf, 4, byte_order, store_unsigned_integer (valbuf, 4, byte_order,
value_address (arg)); arg->address ());
typecode = TYPE_CODE_PTR; typecode = TYPE_CODE_PTR;
len = 4; len = 4;
val = valbuf; val = valbuf;

2
gdb/gdbtypes.c
View file

@ -4009,7 +4009,7 @@ is_unique_ancestor (struct type *base, struct value *val)
return is_unique_ancestor_worker (base, val->type (), &offset, return is_unique_ancestor_worker (base, val->type (), &offset,
value_contents_for_printing (val).data (), value_contents_for_printing (val).data (),
val->embedded_offset (), val->embedded_offset (),
value_address (val), val) == 1; val->address (), val) == 1;
} }
/* See gdbtypes.h. */ /* See gdbtypes.h. */

2
gdb/gnu-v2-abi.c
View file

@ -234,7 +234,7 @@ 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 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. 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. */ Besides, we don't care about the type, just the actual pointer. */
if (value_address (value_field (v, known_type_vptr_fieldno)) == 0) if (value_field (v, known_type_vptr_fieldno)->address () == 0)
return NULL; return NULL;
vtbl = value_as_address (value_field (v, known_type_vptr_fieldno)); vtbl = value_as_address (value_field (v, known_type_vptr_fieldno));

22
gdb/gnu-v3-abi.c
View file

@ -325,7 +325,7 @@ gnuv3_rtti_type (struct value *value,
/* Find the linker symbol for this vtable. */ /* Find the linker symbol for this vtable. */
vtable_symbol vtable_symbol
= lookup_minimal_symbol_by_pc (value_address (vtable) = lookup_minimal_symbol_by_pc (vtable->address ()
+ vtable->embedded_offset ()).minsym; + vtable->embedded_offset ()).minsym;
if (! vtable_symbol) if (! vtable_symbol)
return NULL; return NULL;
@ -804,7 +804,7 @@ hash_value_and_voffset (const void *p)
{ {
const struct value_and_voffset *o = (const struct value_and_voffset *) p; const struct value_and_voffset *o = (const struct value_and_voffset *) p;
return value_address (o->value) + o->value->embedded_offset (); return o->value->address () + o->value->embedded_offset ();
} }
/* Equality function for value_and_voffset. */ /* Equality function for value_and_voffset. */
@ -815,8 +815,8 @@ eq_value_and_voffset (const void *a, const void *b)
const struct value_and_voffset *ova = (const struct value_and_voffset *) a; const struct value_and_voffset *ova = (const struct value_and_voffset *) a;
const struct value_and_voffset *ovb = (const struct value_and_voffset *) b; const struct value_and_voffset *ovb = (const struct value_and_voffset *) b;
return (value_address (ova->value) + ova->value->embedded_offset () return (ova->value->address () + ova->value->embedded_offset ()
== value_address (ovb->value) + ovb->value->embedded_offset ()); == ovb->value->address () + ovb->value->embedded_offset ());
} }
/* Comparison function for value_and_voffset. */ /* Comparison function for value_and_voffset. */
@ -825,9 +825,9 @@ static bool
compare_value_and_voffset (const struct value_and_voffset *va, compare_value_and_voffset (const struct value_and_voffset *va,
const struct value_and_voffset *vb) const struct value_and_voffset *vb)
{ {
CORE_ADDR addra = (value_address (va->value) CORE_ADDR addra = (va->value->address ()
+ va->value->embedded_offset ()); + va->value->embedded_offset ());
CORE_ADDR addrb = (value_address (vb->value) CORE_ADDR addrb = (vb->value->address ()
+ vb->value->embedded_offset ()); + vb->value->embedded_offset ());
return addra < addrb; return addra < addrb;
@ -907,15 +907,15 @@ print_one_vtable (struct gdbarch *gdbarch, struct value *value,
CORE_ADDR vt_addr; CORE_ADDR vt_addr;
vtable = gnuv3_get_vtable (gdbarch, type, vtable = gnuv3_get_vtable (gdbarch, type,
value_address (value) value->address ()
+ value->embedded_offset ()); + value->embedded_offset ());
vt_addr = value_address (value_field (vtable, vt_addr = value_field (vtable,
vtable_field_virtual_functions)); vtable_field_virtual_functions)->address ();
gdb_printf (_("vtable for '%s' @ %s (subobject @ %s):\n"), gdb_printf (_("vtable for '%s' @ %s (subobject @ %s):\n"),
TYPE_SAFE_NAME (type), TYPE_SAFE_NAME (type),
paddress (gdbarch, vt_addr), paddress (gdbarch, vt_addr),
paddress (gdbarch, (value_address (value) paddress (gdbarch, (value->address ()
+ value->embedded_offset ()))); + value->embedded_offset ())));
for (i = 0; i <= max_voffset; ++i) for (i = 0; i <= max_voffset; ++i)
@ -1138,7 +1138,7 @@ gnuv3_get_typeid (struct value *value)
&& gnuv3_dynamic_class (type)) && gnuv3_dynamic_class (type))
{ {
struct value *vtable, *typeinfo_value; struct value *vtable, *typeinfo_value;
CORE_ADDR address = value_address (value) + value->embedded_offset (); CORE_ADDR address = value->address () + value->embedded_offset ();
vtable = gnuv3_get_vtable (gdbarch, type, address); vtable = gnuv3_get_vtable (gdbarch, type, address);
if (vtable == NULL) if (vtable == NULL)

2
gdb/go-valprint.c
View file

@ -105,7 +105,7 @@ go_language::value_print_inner (struct value *val, struct ui_file *stream,
if (! options->raw) if (! options->raw)
{ {
print_go_string (type, val->embedded_offset (), print_go_string (type, val->embedded_offset (),
value_address (val), val->address (),
stream, recurse, val, options); stream, recurse, val, options);
return; return;
} }

4
gdb/guile/scm-value.c
View file

@ -1194,7 +1194,7 @@ gdbscm_value_to_lazy_string (SCM self, SCM rest)
low_bound, low_bound,
low_bound + length - 1); low_bound + length - 1);
} }
addr = value_address (value); addr = value->address ();
break; break;
} }
case TYPE_CODE_PTR: case TYPE_CODE_PTR:
@ -1204,7 +1204,7 @@ gdbscm_value_to_lazy_string (SCM self, SCM rest)
break; break;
default: default:
/* Should flag an error here. PR 20769. */ /* Should flag an error here. PR 20769. */
addr = value_address (value); addr = value->address ();
break; break;
} }

4
gdb/infcall.c
View file

@ -290,7 +290,7 @@ find_function_addr (struct value *function,
/* Determine address to call. */ /* Determine address to call. */
if (ftype->code () == TYPE_CODE_FUNC if (ftype->code () == TYPE_CODE_FUNC
|| ftype->code () == TYPE_CODE_METHOD) || ftype->code () == TYPE_CODE_METHOD)
funaddr = value_address (function); funaddr = function->address ();
else if (ftype->code () == TYPE_CODE_PTR) else if (ftype->code () == TYPE_CODE_PTR)
{ {
funaddr = value_as_address (function); funaddr = value_as_address (function);
@ -962,7 +962,7 @@ call_function_by_hand_dummy (struct value *function,
lastval = get_last_thread_stack_temporary (call_thread.get ()); lastval = get_last_thread_stack_temporary (call_thread.get ());
if (lastval != NULL) if (lastval != NULL)
{ {
CORE_ADDR lastval_addr = value_address (lastval); CORE_ADDR lastval_addr = lastval->address ();
if (gdbarch_inner_than (gdbarch, 1, 2)) if (gdbarch_inner_than (gdbarch, 1, 2))
{ {

4
gdb/m2-valprint.c
View file

@ -270,7 +270,7 @@ m2_print_array_contents (struct value *val,
|| ((current_language->la_language == language_m2) || ((current_language->la_language == language_m2)
&& (type->code () == TYPE_CODE_CHAR))) && (type->code () == TYPE_CODE_CHAR)))
&& (options->format == 0 || options->format == 's')) && (options->format == 0 || options->format == 's'))
val_print_string (type, NULL, value_address (val), len+1, stream, val_print_string (type, NULL, val->address (), len+1, stream,
options); options);
else else
{ {
@ -306,7 +306,7 @@ m2_language::value_print_inner (struct value *val, struct ui_file *stream,
struct type *elttype; struct type *elttype;
CORE_ADDR addr; CORE_ADDR addr;
const gdb_byte *valaddr = value_contents_for_printing (val).data (); const gdb_byte *valaddr = value_contents_for_printing (val).data ();
const CORE_ADDR address = value_address (val); const CORE_ADDR address = val->address ();
struct type *type = check_typedef (val->type ()); struct type *type = check_typedef (val->type ());
switch (type->code ()) switch (type->code ())

2
gdb/m32r-tdep.c
View file

@ -698,7 +698,7 @@ m32r_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
&& (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)) && (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION))
{ {
store_unsigned_integer (valbuf, 4, byte_order, store_unsigned_integer (valbuf, 4, byte_order,
value_address (args[argnum])); args[argnum]->address ());
typecode = TYPE_CODE_PTR; typecode = TYPE_CODE_PTR;
len = 4; len = 4;
val = valbuf; val = valbuf;

2
gdb/mips-tdep.c
View file

@ -4604,7 +4604,7 @@ mips_eabi_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{ {
gdb_assert (abi_regsize <= ARRAY_SIZE (ref_valbuf)); gdb_assert (abi_regsize <= ARRAY_SIZE (ref_valbuf));
store_unsigned_integer (ref_valbuf, abi_regsize, byte_order, store_unsigned_integer (ref_valbuf, abi_regsize, byte_order,
value_address (arg)); arg->address ());
typecode = TYPE_CODE_PTR; typecode = TYPE_CODE_PTR;
len = abi_regsize; len = abi_regsize;
val = ref_valbuf; val = ref_valbuf;

2
gdb/mn10300-tdep.c
View file

@ -1212,7 +1212,7 @@ mn10300_push_dummy_call (struct gdbarch *gdbarch,
arg_len = push_size; arg_len = push_size;
gdb_assert (push_size <= MN10300_MAX_REGISTER_SIZE); gdb_assert (push_size <= MN10300_MAX_REGISTER_SIZE);
store_unsigned_integer (valbuf, push_size, byte_order, store_unsigned_integer (valbuf, push_size, byte_order,
value_address (*args)); (*args)->address ());
val = &valbuf[0]; val = &valbuf[0];
} }
else else

2
gdb/msp430-tdep.c
View file

@ -703,7 +703,7 @@ msp430_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
{ {
/* Aggregates of any size are passed by reference. */ /* Aggregates of any size are passed by reference. */
store_unsigned_integer (struct_addr_buf, 4, byte_order, store_unsigned_integer (struct_addr_buf, 4, byte_order,
value_address (arg)); arg->address ());
arg_bits = struct_addr_buf; arg_bits = struct_addr_buf;
arg_size = (code_model == MSP_LARGE_CODE_MODEL) ? 4 : 2; arg_size = (code_model == MSP_LARGE_CODE_MODEL) ? 4 : 2;
} }

4
gdb/or1k-tdep.c
View file

@ -672,7 +672,7 @@ or1k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
if ((TYPE_CODE_STRUCT == typecode) || (TYPE_CODE_UNION == typecode) if ((TYPE_CODE_STRUCT == typecode) || (TYPE_CODE_UNION == typecode)
|| (len > bpw * 2)) || (len > bpw * 2))
{ {
CORE_ADDR valaddr = value_address (arg); CORE_ADDR valaddr = arg->address ();
/* If the arg is fabricated (i.e. 3*i, instead of i) valaddr is /* If the arg is fabricated (i.e. 3*i, instead of i) valaddr is
undefined. */ undefined. */
@ -792,7 +792,7 @@ or1k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
|| (len > bpw * 2)) || (len > bpw * 2))
{ {
store_unsigned_integer (valbuf, bpa, byte_order, store_unsigned_integer (valbuf, bpa, byte_order,
value_address (arg)); arg->address ());
len = bpa; len = bpa;
val = valbuf; val = valbuf;
} }

8
gdb/p-valprint.c
View file

@ -143,7 +143,7 @@ pascal_language::value_print_inner (struct value *val,
break; break;
} }
/* Array of unspecified length: treat like pointer to first elt. */ /* Array of unspecified length: treat like pointer to first elt. */
addr = value_address (val); addr = val->address ();
} }
goto print_unpacked_pointer; goto print_unpacked_pointer;
@ -748,7 +748,7 @@ pascal_object_print_value (struct value *val, struct ui_file *stream,
if (boffset < 0 || boffset >= type->length ()) if (boffset < 0 || boffset >= type->length ())
{ {
CORE_ADDR address= value_address (val); CORE_ADDR address= val->address ();
gdb::byte_vector buf (baseclass->length ()); gdb::byte_vector buf (baseclass->length ());
if (target_read_memory (address + boffset, buf.data (), if (target_read_memory (address + boffset, buf.data (),
@ -836,7 +836,7 @@ pascal_object_print_static_field (struct value *val,
while (--i >= 0) while (--i >= 0)
{ {
if (value_address (val) == first_dont_print[i]) if (val->address () == first_dont_print[i])
{ {
fputs_styled (_("\ fputs_styled (_("\
<same as static member of an already seen type>"), <same as static member of an already seen type>"),
@ -845,7 +845,7 @@ pascal_object_print_static_field (struct value *val,
} }
} }
addr = value_address (val); addr = val->address ();
obstack_grow (&dont_print_statmem_obstack, (char *) &addr, obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
sizeof (CORE_ADDR)); sizeof (CORE_ADDR));

4
gdb/ppc-linux-nat.c
View file

@ -2510,7 +2510,7 @@ ppc_linux_nat_target::check_condition (CORE_ADDR watch_addr,
if (num_accesses_left == 1 && num_accesses_right == 0 if (num_accesses_left == 1 && num_accesses_right == 0
&& VALUE_LVAL (left_val) == lval_memory && VALUE_LVAL (left_val) == lval_memory
&& value_address (left_val) == watch_addr) && left_val->address () == watch_addr)
{ {
*data_value = value_as_long (right_val); *data_value = value_as_long (right_val);
@ -2520,7 +2520,7 @@ ppc_linux_nat_target::check_condition (CORE_ADDR watch_addr,
} }
else if (num_accesses_left == 0 && num_accesses_right == 1 else if (num_accesses_left == 0 && num_accesses_right == 1
&& VALUE_LVAL (right_val) == lval_memory && VALUE_LVAL (right_val) == lval_memory
&& value_address (right_val) == watch_addr) && right_val->address () == watch_addr)
{ {
*data_value = value_as_long (left_val); *data_value = value_as_long (left_val);

12
gdb/printcmd.c
View file

@ -298,7 +298,7 @@ print_formatted (struct value *val, int size,
int len = type->length (); int len = type->length ();
if (VALUE_LVAL (val) == lval_memory) if (VALUE_LVAL (val) == lval_memory)
next_address = value_address (val) + len; next_address = val->address () + len;
if (size) if (size)
{ {
@ -308,9 +308,9 @@ print_formatted (struct value *val, int size,
{ {
struct type *elttype = val->type (); struct type *elttype = val->type ();
next_address = (value_address (val) next_address = (val->address ()
+ val_print_string (elttype, NULL, + val_print_string (elttype, NULL,
value_address (val), -1, val->address (), -1,
stream, options) * len); stream, options) * len);
} }
return; return;
@ -318,9 +318,9 @@ print_formatted (struct value *val, int size,
case 'i': case 'i':
/* We often wrap here if there are long symbolic names. */ /* We often wrap here if there are long symbolic names. */
stream->wrap_here (4); stream->wrap_here (4);
next_address = (value_address (val) next_address = (val->address ()
+ gdb_print_insn (type->arch (), + gdb_print_insn (type->arch (),
value_address (val), stream, val->address (), stream,
&branch_delay_insns)); &branch_delay_insns));
return; return;
} }
@ -1905,7 +1905,7 @@ x_command (const char *exp, int from_tty)
pointers to functions. This makes "x/i main" work. */ pointers to functions. This makes "x/i main" work. */
if (val->type ()->code () == TYPE_CODE_FUNC if (val->type ()->code () == TYPE_CODE_FUNC
&& VALUE_LVAL (val) == lval_memory) && VALUE_LVAL (val) == lval_memory)
next_address = value_address (val); next_address = val->address ();
else else
next_address = value_as_address (val); next_address = value_as_address (val);

4
gdb/python/py-value.c
View file

@ -538,7 +538,7 @@ valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
low_bound, low_bound,
low_bound + length - 1); low_bound + length - 1);
} }
addr = value_address (value); addr = value->address ();
break; break;
} }
case TYPE_CODE_PTR: case TYPE_CODE_PTR:
@ -548,7 +548,7 @@ valpy_lazy_string (PyObject *self, PyObject *args, PyObject *kw)
break; break;
default: default:
/* Should flag an error here. PR 20769. */ /* Should flag an error here. PR 20769. */
addr = value_address (value); addr = value->address ();
break; break;
} }

8
gdb/rust-lang.c
View file

@ -351,7 +351,7 @@ rust_val_print_slice (struct value *val, struct ui_file *stream, int recurse,
llen - 1); llen - 1);
struct value *array = allocate_value_lazy (array_type); struct value *array = allocate_value_lazy (array_type);
VALUE_LVAL (array) = lval_memory; VALUE_LVAL (array) = lval_memory;
set_value_address (array, value_as_address (base)); array->set_address (value_as_address (base));
value_fetch_lazy (array); value_fetch_lazy (array);
generic_value_print (array, stream, recurse, options, generic_value_print (array, stream, recurse, options,
&rust_decorations); &rust_decorations);
@ -458,7 +458,7 @@ rust_language::print_enum (struct value *val, struct ui_file *stream,
gdb::array_view<const gdb_byte> view gdb::array_view<const gdb_byte> view
(value_contents_for_printing (val).data (), (value_contents_for_printing (val).data (),
val->type ()->length ()); val->type ()->length ());
type = resolve_dynamic_type (type, view, value_address (val)); type = resolve_dynamic_type (type, view, val->address ());
if (rust_empty_enum_p (type)) if (rust_empty_enum_p (type))
{ {
@ -1375,7 +1375,7 @@ rust_struct_anon::evaluate (struct type *expect_type,
if (rust_enum_p (type)) if (rust_enum_p (type))
{ {
type = resolve_dynamic_type (type, value_contents (lhs), type = resolve_dynamic_type (type, value_contents (lhs),
value_address (lhs)); lhs->address ());
if (rust_empty_enum_p (type)) if (rust_empty_enum_p (type))
error (_("Cannot access field %d of empty enum %s"), error (_("Cannot access field %d of empty enum %s"),
@ -1438,7 +1438,7 @@ rust_structop::evaluate (struct type *expect_type,
if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type)) if (type->code () == TYPE_CODE_STRUCT && rust_enum_p (type))
{ {
type = resolve_dynamic_type (type, value_contents (lhs), type = resolve_dynamic_type (type, value_contents (lhs),
value_address (lhs)); lhs->address ());
if (rust_empty_enum_p (type)) if (rust_empty_enum_p (type))
error (_("Cannot access field %s of empty enum %s"), error (_("Cannot access field %s of empty enum %s"),

2
gdb/stack.c
View file

@ -1726,7 +1726,7 @@ info_frame_command_core (frame_info_ptr fi, bool selected_frame_p)
else if (VALUE_LVAL (value) == lval_memory) else if (VALUE_LVAL (value) == lval_memory)
{ {
gdb_printf (" Previous frame's sp at "); gdb_printf (" Previous frame's sp at ");
gdb_puts (paddress (gdbarch, value_address (value))); gdb_puts (paddress (gdbarch, value->address ()));
gdb_printf ("\n"); gdb_printf ("\n");
} }
else if (VALUE_LVAL (value) == lval_register) else if (VALUE_LVAL (value) == lval_register)

2
gdb/tracepoint.c
View file

@ -1376,7 +1376,7 @@ encode_actions_1 (struct command_line *action,
{ {
/* Safe because we know it's a simple expression. */ /* Safe because we know it's a simple expression. */
tempval = evaluate_expression (exp.get ()); tempval = evaluate_expression (exp.get ());
addr = value_address (tempval); addr = tempval->address ();
expr::unop_memval_operation *memop expr::unop_memval_operation *memop
= (gdb::checked_static_cast<expr::unop_memval_operation *> = (gdb::checked_static_cast<expr::unop_memval_operation *>
(exp->op.get ())); (exp->op.get ()));

2
gdb/v850-tdep.c
View file

@ -1059,7 +1059,7 @@ v850_push_dummy_call (struct gdbarch *gdbarch,
&& (*args)->type ()->length () > E_MAX_RETTYPE_SIZE_IN_REGS) && (*args)->type ()->length () > E_MAX_RETTYPE_SIZE_IN_REGS)
{ {
store_unsigned_integer (valbuf, 4, byte_order, store_unsigned_integer (valbuf, 4, byte_order,
value_address (*args)); (*args)->address ());
len = 4; len = 4;
val = valbuf; val = valbuf;
} }

4
gdb/valarith.c
View file

@ -193,7 +193,7 @@ value_subscript (struct value *array, LONGEST index)
struct value *val = allocate_value (elt_type); struct value *val = allocate_value (elt_type);
mark_value_bytes_unavailable (val, 0, elt_size); mark_value_bytes_unavailable (val, 0, elt_size);
VALUE_LVAL (val) = lval_memory; VALUE_LVAL (val) = lval_memory;
set_value_address (val, value_address (array) + elt_size * index); val->set_address (array->address () + elt_size * index);
return val; return val;
} }
@ -249,7 +249,7 @@ value_subscripted_rvalue (struct value *array, LONGEST index,
{ {
CORE_ADDR address; CORE_ADDR address;
address = value_address (array) + elt_offs; address = array->address () + elt_offs;
elt_type = resolve_dynamic_type (elt_type, {}, address); elt_type = resolve_dynamic_type (elt_type, {}, address);
} }

44
gdb/valops.c
View file

@ -253,7 +253,7 @@ value_cast_structs (struct type *type, struct value *v2)
if (real_type) if (real_type)
{ {
v = value_full_object (v2, real_type, full, top, using_enc); v = value_full_object (v2, real_type, full, top, using_enc);
v = value_at_lazy (real_type, value_address (v)); v = value_at_lazy (real_type, v->address ());
real_type = v->type (); real_type = v->type ();
/* We might be trying to cast to the outermost enclosing /* We might be trying to cast to the outermost enclosing
@ -275,9 +275,9 @@ value_cast_structs (struct type *type, struct value *v2)
if (v) if (v)
{ {
/* Downcasting is possible (t1 is superclass of v2). */ /* Downcasting is possible (t1 is superclass of v2). */
CORE_ADDR addr2 = value_address (v2) + v2->embedded_offset (); CORE_ADDR addr2 = v2->address () + v2->embedded_offset ();
addr2 -= value_address (v) + v->embedded_offset (); addr2 -= v->address () + v->embedded_offset ();
return value_at (type, addr2); return value_at (type, addr2);
} }
} }
@ -654,7 +654,7 @@ value_cast (struct type *type, struct value *arg2)
return arg2; return arg2;
} }
else if (VALUE_LVAL (arg2) == lval_memory) else if (VALUE_LVAL (arg2) == lval_memory)
return value_at_lazy (to_type, value_address (arg2)); return value_at_lazy (to_type, arg2->address ());
else else
{ {
if (current_language->la_language == language_ada) if (current_language->la_language == language_ada)
@ -876,7 +876,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
error (_("Couldn't determine value's most derived type for dynamic_cast")); error (_("Couldn't determine value's most derived type for dynamic_cast"));
/* Compute the most derived object's address. */ /* Compute the most derived object's address. */
addr = value_address (arg); addr = arg->address ();
if (full) if (full)
{ {
/* Done. */ /* Done. */
@ -904,7 +904,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
if (dynamic_cast_check_1 (resolved_type->target_type (), if (dynamic_cast_check_1 (resolved_type->target_type (),
value_contents_for_printing (tem).data (), value_contents_for_printing (tem).data (),
tem->embedded_offset (), tem->embedded_offset (),
value_address (tem), tem, tem->address (), tem,
rtti_type, addr, rtti_type, addr,
arg_type, arg_type,
&result) == 1) &result) == 1)
@ -920,7 +920,7 @@ value_dynamic_cast (struct type *type, struct value *arg)
&& dynamic_cast_check_2 (resolved_type->target_type (), && dynamic_cast_check_2 (resolved_type->target_type (),
value_contents_for_printing (tem).data (), value_contents_for_printing (tem).data (),
tem->embedded_offset (), tem->embedded_offset (),
value_address (tem), tem, tem->address (), tem,
rtti_type, &result) == 1) rtti_type, &result) == 1)
return value_cast (type, return value_cast (type,
is_ref is_ref
@ -1154,7 +1154,7 @@ value_assign (struct value *toval, struct value *fromval)
{ {
struct value *parent = toval->parent (); struct value *parent = toval->parent ();
changed_addr = value_address (parent) + toval->offset (); changed_addr = parent->address () + toval->offset ();
changed_len = (toval->bitpos () changed_len = (toval->bitpos ()
+ toval->bitsize () + toval->bitsize ()
+ HOST_CHAR_BIT - 1) + HOST_CHAR_BIT - 1)
@ -1181,7 +1181,7 @@ value_assign (struct value *toval, struct value *fromval)
} }
else else
{ {
changed_addr = value_address (toval); changed_addr = toval->address ();
changed_len = type_length_units (type); changed_len = type_length_units (type);
dest_buffer = value_contents (fromval).data (); dest_buffer = value_contents (fromval).data ();
} }
@ -1374,9 +1374,9 @@ value_repeat (struct value *arg1, int count)
val = allocate_repeat_value (arg1->enclosing_type (), count); val = allocate_repeat_value (arg1->enclosing_type (), count);
VALUE_LVAL (val) = lval_memory; VALUE_LVAL (val) = lval_memory;
set_value_address (val, value_address (arg1)); val->set_address (arg1->address ());
read_value_memory (val, 0, val->stack (), value_address (val), read_value_memory (val, 0, val->stack (), val->address (),
value_contents_all_raw (val).data (), value_contents_all_raw (val).data (),
type_length_units (val->enclosing_type ())); type_length_units (val->enclosing_type ()));
@ -1409,7 +1409,7 @@ address_of_variable (struct symbol *var, const struct block *b)
if ((VALUE_LVAL (val) == lval_memory && val->lazy ()) if ((VALUE_LVAL (val) == lval_memory && val->lazy ())
|| type->code () == TYPE_CODE_FUNC) || type->code () == TYPE_CODE_FUNC)
{ {
CORE_ADDR addr = value_address (val); CORE_ADDR addr = val->address ();
return value_from_pointer (lookup_pointer_type (type), addr); return value_from_pointer (lookup_pointer_type (type), addr);
} }
@ -1526,7 +1526,7 @@ value_coerce_array (struct value *arg1)
error (_("Attempt to take address of value not located in memory.")); error (_("Attempt to take address of value not located in memory."));
return value_from_pointer (lookup_pointer_type (type->target_type ()), return value_from_pointer (lookup_pointer_type (type->target_type ()),
value_address (arg1)); arg1->address ());
} }
/* Given a value which is a function, return a value which is a pointer /* Given a value which is a function, return a value which is a pointer
@ -1541,7 +1541,7 @@ value_coerce_function (struct value *arg1)
error (_("Attempt to take address of value not located in memory.")); error (_("Attempt to take address of value not located in memory."));
retval = value_from_pointer (lookup_pointer_type (arg1->type ()), retval = value_from_pointer (lookup_pointer_type (arg1->type ()),
value_address (arg1)); arg1->address ());
return retval; return retval;
} }
@ -1591,7 +1591,7 @@ value_addr (struct value *arg1)
/* Get target memory address. */ /* Get target memory address. */
arg2 = value_from_pointer (lookup_pointer_type (arg1->type ()), arg2 = value_from_pointer (lookup_pointer_type (arg1->type ()),
(value_address (arg1) (arg1->address ()
+ arg1->embedded_offset ())); + arg1->embedded_offset ()));
/* This may be a pointer to a base subobject; so remember the /* This may be a pointer to a base subobject; so remember the
@ -2085,7 +2085,7 @@ struct_field_searcher::search (struct value *arg1, LONGEST offset,
boffset = baseclass_offset (type, i, boffset = baseclass_offset (type, i,
value_contents_for_printing (arg1).data (), value_contents_for_printing (arg1).data (),
arg1->embedded_offset () + offset, arg1->embedded_offset () + offset,
value_address (arg1), arg1->address (),
arg1); arg1);
/* The virtual base class pointer might have been clobbered /* The virtual base class pointer might have been clobbered
@ -2098,7 +2098,7 @@ struct_field_searcher::search (struct value *arg1, LONGEST offset,
{ {
CORE_ADDR base_addr; CORE_ADDR base_addr;
base_addr = value_address (arg1) + boffset; base_addr = arg1->address () + boffset;
v2 = value_at_lazy (basetype, base_addr); v2 = value_at_lazy (basetype, base_addr);
if (target_read_memory (base_addr, if (target_read_memory (base_addr,
value_contents_raw (v2).data (), value_contents_raw (v2).data (),
@ -2278,7 +2278,7 @@ search_struct_method (const char *name, struct value **arg1p,
CORE_ADDR address; CORE_ADDR address;
gdb::byte_vector tmp (baseclass->length ()); gdb::byte_vector tmp (baseclass->length ());
address = value_address (*arg1p); address = (*arg1p)->address ();
if (target_read_memory (address + offset, if (target_read_memory (address + offset,
tmp.data (), baseclass->length ()) != 0) tmp.data (), baseclass->length ()) != 0)
@ -2298,7 +2298,7 @@ search_struct_method (const char *name, struct value **arg1p,
} }
base_offset = baseclass_offset (type, i, base_valaddr, base_offset = baseclass_offset (type, i, base_valaddr,
this_offset, value_address (base_val), this_offset, base_val->address (),
base_val); base_val);
} }
else else
@ -2560,7 +2560,7 @@ find_method_list (struct value **argp, const char *method,
base_offset = baseclass_offset (type, i, base_offset = baseclass_offset (type, i,
value_contents_for_printing (*argp).data (), value_contents_for_printing (*argp).data (),
(*argp)->offset () + offset, (*argp)->offset () + offset,
value_address (*argp), *argp); (*argp)->address (), *argp);
} }
else /* Non-virtual base, simply use bit position from debug else /* Non-virtual base, simply use bit position from debug
info. */ info. */
@ -3766,7 +3766,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j))); result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
cplus_make_method_ptr (result->type (), cplus_make_method_ptr (result->type (),
value_contents_writeable (result).data (), value_contents_writeable (result).data (),
value_address (v), 0); v->address (), 0);
} }
} }
return result; return result;
@ -3977,7 +3977,7 @@ value_full_object (struct value *argp,
/* Go back by the computed top_offset from the beginning of the /* Go back by the computed top_offset from the beginning of the
object, adjusting for the embedded offset of argp if that's what object, adjusting for the embedded offset of argp if that's what
value_rtti_type used for its computation. */ value_rtti_type used for its computation. */
new_val = value_at_lazy (real_type, value_address (argp) - top + new_val = value_at_lazy (real_type, argp->address () - top +
(using_enc ? 0 : argp->embedded_offset ())); (using_enc ? 0 : argp->embedded_offset ()));
new_val->deprecated_set_type (argp->type ()); new_val->deprecated_set_type (argp->type ());
new_val->set_embedded_offset ((using_enc new_val->set_embedded_offset ((using_enc

4
gdb/valprint.c
View file

@ -494,7 +494,7 @@ generic_val_print_array (struct value *val,
else else
{ {
/* Array of unspecified length: treat like pointer to first elt. */ /* Array of unspecified length: treat like pointer to first elt. */
print_unpacked_pointer (type, elttype, value_address (val), print_unpacked_pointer (type, elttype, val->address (),
stream, options); stream, options);
} }
@ -965,7 +965,7 @@ generic_value_print (struct value *val, struct ui_file *stream, int recurse,
if (options->format) if (options->format)
value_print_scalar_formatted (val, options, 0, stream); value_print_scalar_formatted (val, options, 0, stream);
else else
generic_val_print_func (type, 0, value_address (val), stream, generic_val_print_func (type, 0, val->address (), stream,
val, options); val, options);
break; break;

51
gdb/value.c
View file

@ -1399,34 +1399,34 @@ value::computed_closure () const
} }
CORE_ADDR CORE_ADDR
value_address (const struct value *value) value::address () const
{ {
if (value->m_lval != lval_memory) if (m_lval != lval_memory)
return 0; return 0;
if (value->m_parent != NULL) if (m_parent != NULL)
return value_address (value->m_parent.get ()) + value->m_offset; return m_parent.get ()->address () + m_offset;
if (NULL != TYPE_DATA_LOCATION (value->type ())) if (NULL != TYPE_DATA_LOCATION (type ()))
{ {
gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (value->type ())); gdb_assert (PROP_CONST == TYPE_DATA_LOCATION_KIND (type ()));
return TYPE_DATA_LOCATION_ADDR (value->type ()); return TYPE_DATA_LOCATION_ADDR (type ());
} }
return value->m_location.address + value->m_offset; return m_location.address + m_offset;
} }
CORE_ADDR CORE_ADDR
value_raw_address (const struct value *value) value::raw_address () const
{ {
if (value->m_lval != lval_memory) if (m_lval != lval_memory)
return 0; return 0;
return value->m_location.address; return m_location.address;
} }
void void
set_value_address (struct value *value, CORE_ADDR addr) value::set_address (CORE_ADDR addr)
{ {
gdb_assert (value->m_lval == lval_memory); gdb_assert (m_lval == lval_memory);
value->m_location.address = addr; m_location.address = addr;
} }
struct internalvar ** struct internalvar **
@ -1677,7 +1677,7 @@ set_value_component_location (struct value *component,
type = whole->type (); type = whole->type ();
if (NULL != TYPE_DATA_LOCATION (type) if (NULL != TYPE_DATA_LOCATION (type)
&& TYPE_DATA_LOCATION_KIND (type) == PROP_CONST) && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST)
set_value_address (component, TYPE_DATA_LOCATION_ADDR (type)); component->set_address (TYPE_DATA_LOCATION_ADDR (type));
/* Similarly, if the COMPONENT value has a dynamically resolved location /* Similarly, if the COMPONENT value has a dynamically resolved location
property then update its address. */ property then update its address. */
@ -1709,7 +1709,7 @@ set_value_component_location (struct value *component,
} }
else else
gdb_assert (VALUE_LVAL (component) == lval_memory); gdb_assert (VALUE_LVAL (component) == lval_memory);
set_value_address (component, TYPE_DATA_LOCATION_ADDR (type)); component->set_address (TYPE_DATA_LOCATION_ADDR (type));
} }
} }
@ -2655,7 +2655,7 @@ value_as_address (struct value *val)
Upon entry to this function, if VAL is a value of type `function' Upon entry to this function, if VAL is a value of type `function'
(that is, TYPE_CODE (val->type ()) == TYPE_CODE_FUNC), then (that is, TYPE_CODE (val->type ()) == TYPE_CODE_FUNC), then
value_address (val) is the address of the function. This is what val->address () is the address of the function. This is what
you'll get if you evaluate an expression like `main'. The call you'll get if you evaluate an expression like `main'. The call
to COERCE_ARRAY below actually does all the usual unary to COERCE_ARRAY below actually does all the usual unary
conversions, which includes converting values of type `function' conversions, which includes converting values of type `function'
@ -2675,7 +2675,7 @@ value_as_address (struct value *val)
function, just return its address directly. */ function, just return its address directly. */
if (val->type ()->code () == TYPE_CODE_FUNC if (val->type ()->code () == TYPE_CODE_FUNC
|| val->type ()->code () == TYPE_CODE_METHOD) || val->type ()->code () == TYPE_CODE_METHOD)
return value_address (val); return val->address ();
val = coerce_array (val); val = coerce_array (val);
@ -2988,7 +2988,7 @@ value_primitive_field (struct value *arg1, LONGEST offset,
boffset = baseclass_offset (arg_type, fieldno, boffset = baseclass_offset (arg_type, fieldno,
value_contents (arg1).data (), value_contents (arg1).data (),
arg1->embedded_offset (), arg1->embedded_offset (),
value_address (arg1), arg1->address (),
arg1); arg1);
else else
boffset = arg_type->field (fieldno).loc_bitpos () / 8; boffset = arg_type->field (fieldno).loc_bitpos () / 8;
@ -3082,7 +3082,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
VALUE_LVAL (v) = lval_memory; VALUE_LVAL (v) = lval_memory;
if (sym) if (sym)
{ {
set_value_address (v, sym->value_block ()->entry_pc ()); v->set_address (sym->value_block ()->entry_pc ());
} }
else else
{ {
@ -3091,8 +3091,7 @@ value_fn_field (struct value **arg1p, struct fn_field *f,
struct objfile *objfile = msym.objfile; struct objfile *objfile = msym.objfile;
struct gdbarch *gdbarch = objfile->arch (); struct gdbarch *gdbarch = objfile->arch ();
set_value_address (v, v->set_address (gdbarch_convert_from_func_ptr_addr
gdbarch_convert_from_func_ptr_addr
(gdbarch, msym.value_address (), (gdbarch, msym.value_address (),
current_inferior ()->top_target ())); current_inferior ()->top_target ()));
} }
@ -3511,7 +3510,7 @@ value_from_contents_and_address_unresolved (struct type *type,
else else
v = value_from_contents (type, valaddr); v = value_from_contents (type, valaddr);
VALUE_LVAL (v) = lval_memory; VALUE_LVAL (v) = lval_memory;
set_value_address (v, address); v->set_address (address);
return v; return v;
} }
@ -3540,7 +3539,7 @@ value_from_contents_and_address (struct type *type,
&& TYPE_DATA_LOCATION_KIND (resolved_type_no_typedef) == PROP_CONST) && TYPE_DATA_LOCATION_KIND (resolved_type_no_typedef) == PROP_CONST)
address = TYPE_DATA_LOCATION_ADDR (resolved_type_no_typedef); address = TYPE_DATA_LOCATION_ADDR (resolved_type_no_typedef);
VALUE_LVAL (v) = lval_memory; VALUE_LVAL (v) = lval_memory;
set_value_address (v, address); v->set_address (address);
return v; return v;
} }
@ -3828,7 +3827,7 @@ value_fetch_lazy_memory (struct value *val)
{ {
gdb_assert (VALUE_LVAL (val) == lval_memory); gdb_assert (VALUE_LVAL (val) == lval_memory);
CORE_ADDR addr = value_address (val); CORE_ADDR addr = val->address ();
struct type *type = check_typedef (val->enclosing_type ()); struct type *type = check_typedef (val->enclosing_type ());
/* Figure out how much we should copy from memory. Usually, this is just /* Figure out how much we should copy from memory. Usually, this is just
@ -3949,7 +3948,7 @@ value_fetch_lazy_register (struct value *val)
else if (VALUE_LVAL (new_val) == lval_memory) else if (VALUE_LVAL (new_val) == lval_memory)
gdb_printf (&debug_file, " address=%s", gdb_printf (&debug_file, " address=%s",
paddress (gdbarch, paddress (gdbarch,
value_address (new_val))); new_val->address ()));
else else
gdb_printf (&debug_file, " computed"); gdb_printf (&debug_file, " computed");

26
gdb/value.h
View file

@ -325,6 +325,19 @@ struct value
void set_initialized (int value) void set_initialized (int value)
{ m_initialized = value; } { m_initialized = value; }
/* If lval == lval_memory, return the address in the inferior. If
lval == lval_register, return the byte offset into the registers
structure. Otherwise, return 0. The returned address
includes the offset, if any. */
CORE_ADDR address () const;
/* Like address, except the result does not include value's
offset. */
CORE_ADDR raw_address () const;
/* Set the address of a value. */
void set_address (CORE_ADDR);
/* Type of value; either not an lval, or one of the various /* Type of value; either not an lval, or one of the various
different possible kinds of lval. */ different possible kinds of lval. */
@ -678,19 +691,6 @@ extern void set_value_component_location (struct value *component,
possible kinds of lval. */ possible kinds of lval. */
#define VALUE_LVAL(val) (*((val)->deprecated_lval_hack ())) #define VALUE_LVAL(val) (*((val)->deprecated_lval_hack ()))
/* If lval == lval_memory, return the address in the inferior. If
lval == lval_register, return the byte offset into the registers
structure. Otherwise, return 0. The returned address
includes the offset, if any. */
extern CORE_ADDR value_address (const struct value *);
/* Like value_address, except the result does not include value's
offset. */
extern CORE_ADDR value_raw_address (const struct value *);
/* Set the address of a value. */
extern void set_value_address (struct value *, CORE_ADDR);
/* Pointer to internal variable. */ /* Pointer to internal variable. */
extern struct internalvar **deprecated_value_internalvar_hack (struct value *); extern struct internalvar **deprecated_value_internalvar_hack (struct value *);
#define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val)) #define VALUE_INTERNALVAR(val) (*deprecated_value_internalvar_hack (val))