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

Turn some value_contents functions into methods

Browse source 
This turns value_contents_raw, value_contents_writeable, and
value_contents_all_raw into methods on value.  The remaining functions
will be changed later in the series; they were a bit trickier and so I
didn't include them in this patch.

Approved-By: Simon Marchi <simon.marchi@efficios.com>
This commit is contained in:
Tom Tromey 2023-01-31 13:45:40 -07:00
parent ee7bb2944b
commit bbe912ba88
32 changed files with 142 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

2
gdb/aarch64-linux-tdep.c
View file

@ -1668,7 +1668,7 @@ aarch64_linux_set_memtags (struct gdbarch *gdbarch, struct value *address,
/* Update the value's content with the tag. */ /* Update the value's content with the tag. */
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
gdb_byte *srcbuf = value_contents_raw (address).data (); gdb_byte *srcbuf = address->contents_raw ().data ();
store_unsigned_integer (srcbuf, sizeof (addr), byte_order, addr); store_unsigned_integer (srcbuf, sizeof (addr), byte_order, addr);
} }
else else

6
gdb/aarch64-tdep.c
View file

@ -2494,7 +2494,7 @@ aarch64_return_value (struct gdbarch *gdbarch, struct value *func_value,
{ {
*read_value = value::allocate (valtype); *read_value = value::allocate (valtype);
aarch64_extract_return_value (valtype, regcache, aarch64_extract_return_value (valtype, regcache,
value_contents_raw (*read_value).data ()); (*read_value)->contents_raw ().data ());
} }
aarch64_debug_printf ("return value in registers"); aarch64_debug_printf ("return value in registers");
@ -2769,7 +2769,7 @@ aarch64_pseudo_read_value_1 (struct gdbarch *gdbarch,
mark_value_bytes_unavailable (result_value, 0, mark_value_bytes_unavailable (result_value, 0,
result_value->type ()->length ()); result_value->type ()->length ());
else else
memcpy (value_contents_raw (result_value).data (), reg_buf, regsize); memcpy (result_value->contents_raw ().data (), reg_buf, regsize);
return result_value; return result_value;
} }
@ -2803,7 +2803,7 @@ aarch64_pseudo_read_value (struct gdbarch *gdbarch, readable_regcache *regcache,
if (regcache->raw_read_part (x_regnum, offset, 4, data) != REG_VALID) if (regcache->raw_read_part (x_regnum, offset, 4, data) != REG_VALID)
mark_value_bytes_unavailable (result_value, 0, 4); mark_value_bytes_unavailable (result_value, 0, 4);
else else
memcpy (value_contents_raw (result_value).data (), data, 4); memcpy (result_value->contents_raw ().data (), data, 4);
return result_value; return result_value;
} }

26
gdb/ada-lang.c
View file

@ -2846,7 +2846,7 @@ ada_value_primitive_packed_val (struct value *obj, const gdb_byte *valaddr,
} }
else else
v->set_bitsize (bit_size); v->set_bitsize (bit_size);
unpacked = value_contents_writeable (v).data (); unpacked = v->contents_writeable ().data ();
if (bit_size == 0) if (bit_size == 0)
{ {
@ -2921,7 +2921,7 @@ ada_value_assign (struct value *toval, struct value *fromval)
write_memory_with_notification (to_addr, buffer, len); write_memory_with_notification (to_addr, buffer, len);
val = value_copy (toval); val = value_copy (toval);
memcpy (value_contents_raw (val).data (), memcpy (val->contents_raw ().data (),
value_contents (fromval).data (), value_contents (fromval).data (),
type->length ()); type->length ());
val->deprecated_set_type (type); val->deprecated_set_type (type);
@ -2970,13 +2970,13 @@ value_assign_to_component (struct value *container, struct value *component,
= component->type ()->length () * TARGET_CHAR_BIT - bits; = component->type ()->length () * TARGET_CHAR_BIT - bits;
else else
src_offset = 0; src_offset = 0;
copy_bitwise ((value_contents_writeable (container).data () copy_bitwise ((container->contents_writeable ().data ()
+ offset_in_container), + offset_in_container),
container->bitpos () + bit_offset_in_container, container->bitpos () + bit_offset_in_container,
value_contents (val).data (), src_offset, bits, 1); value_contents (val).data (), src_offset, bits, 1);
} }
else else
copy_bitwise ((value_contents_writeable (container).data () copy_bitwise ((container->contents_writeable ().data ()
+ offset_in_container), + offset_in_container),
container->bitpos () + bit_offset_in_container, container->bitpos () + bit_offset_in_container,
value_contents (val).data (), 0, bits, 0); value_contents (val).data (), 0, bits, 0);
@ -4529,7 +4529,7 @@ ada_convert_actual (struct value *actual, struct type *formal_type0)
actual_type = ada_check_typedef (actual->type ()); actual_type = ada_check_typedef (actual->type ());
val = value::allocate (actual_type); val = value::allocate (actual_type);
copy (value_contents (actual), value_contents_raw (val)); copy (value_contents (actual), val->contents_raw ());
actual = ensure_lval (val); actual = ensure_lval (val);
} }
result = value_addr (actual); result = value_addr (actual);
@ -4592,12 +4592,12 @@ make_array_descriptor (struct type *type, struct value *arr)
i > 0; i -= 1) i > 0; i -= 1)
{ {
modify_field (bounds->type (), modify_field (bounds->type (),
value_contents_writeable (bounds).data (), bounds->contents_writeable ().data (),
ada_array_bound (arr, i, 0), ada_array_bound (arr, i, 0),
desc_bound_bitpos (bounds_type, i, 0), desc_bound_bitpos (bounds_type, i, 0),
desc_bound_bitsize (bounds_type, i, 0)); desc_bound_bitsize (bounds_type, i, 0));
modify_field (bounds->type (), modify_field (bounds->type (),
value_contents_writeable (bounds).data (), bounds->contents_writeable ().data (),
ada_array_bound (arr, i, 1), ada_array_bound (arr, i, 1),
desc_bound_bitpos (bounds_type, i, 1), desc_bound_bitpos (bounds_type, i, 1),
desc_bound_bitsize (bounds_type, i, 1)); desc_bound_bitsize (bounds_type, i, 1));
@ -4606,14 +4606,14 @@ make_array_descriptor (struct type *type, struct value *arr)
bounds = ensure_lval (bounds); bounds = ensure_lval (bounds);
modify_field (descriptor->type (), modify_field (descriptor->type (),
value_contents_writeable (descriptor).data (), descriptor->contents_writeable ().data (),
value_pointer (ensure_lval (arr), value_pointer (ensure_lval (arr),
desc_type->field (0).type ()), desc_type->field (0).type ()),
fat_pntr_data_bitpos (desc_type), fat_pntr_data_bitpos (desc_type),
fat_pntr_data_bitsize (desc_type)); fat_pntr_data_bitsize (desc_type));
modify_field (descriptor->type (), modify_field (descriptor->type (),
value_contents_writeable (descriptor).data (), descriptor->contents_writeable ().data (),
value_pointer (bounds, value_pointer (bounds,
desc_type->field (1).type ()), desc_type->field (1).type ()),
fat_pntr_bounds_bitpos (desc_type), fat_pntr_bounds_bitpos (desc_type),
@ -9282,7 +9282,7 @@ ada_promote_array_of_integrals (struct type *type, struct value *val)
error (_("unable to determine array bounds")); error (_("unable to determine array bounds"));
value *res = value::allocate (type); value *res = value::allocate (type);
gdb::array_view<gdb_byte> res_contents = value_contents_writeable (res); gdb::array_view<gdb_byte> res_contents = res->contents_writeable ();
/* Promote each array element. */ /* Promote each array element. */
for (i = 0; i < hi - lo + 1; i++) for (i = 0; i < hi - lo + 1; i++)
@ -9404,7 +9404,7 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
} }
val = value::allocate (type1); val = value::allocate (type1);
store_unsigned_integer (value_contents_raw (val).data (), store_unsigned_integer (val->contents_raw ().data (),
val->type ()->length (), val->type ()->length (),
type_byte_order (type1), v); type_byte_order (type1), v);
return val; return val;
@ -10668,7 +10668,7 @@ ada_string_operation::evaluate (struct type *expect_type,
struct type *stringtype struct type *stringtype
= lookup_array_range_type (char_type, 1, str.length ()); = lookup_array_range_type (char_type, 1, str.length ());
struct value *val = value::allocate (stringtype); struct value *val = value::allocate (stringtype);
memcpy (value_contents_raw (val).data (), str.c_str (), memcpy (val->contents_raw ().data (), str.c_str (),
str.length ()); str.length ());
return val; return val;
} }
@ -10703,7 +10703,7 @@ ada_string_operation::evaluate (struct type *expect_type,
obstack_object_size (&converted) obstack_object_size (&converted)
/ char_type->length ()); / char_type->length ());
struct value *val = value::allocate (stringtype); struct value *val = value::allocate (stringtype);
memcpy (value_contents_raw (val).data (), memcpy (val->contents_raw ().data (),
obstack_base (&converted), obstack_base (&converted),
obstack_object_size (&converted)); obstack_object_size (&converted));
return val; return val;

4
gdb/amd64-tdep.c
View file

@ -358,7 +358,7 @@ amd64_pseudo_register_read_value (struct gdbarch *gdbarch,
value *result_value = value::allocate (register_type (gdbarch, regnum)); value *result_value = value::allocate (register_type (gdbarch, regnum));
VALUE_LVAL (result_value) = lval_register; VALUE_LVAL (result_value) = lval_register;
VALUE_REGNUM (result_value) = regnum; VALUE_REGNUM (result_value) = regnum;
gdb_byte *buf = value_contents_raw (result_value).data (); gdb_byte *buf = result_value->contents_raw ().data ();
if (i386_byte_regnum_p (gdbarch, regnum)) if (i386_byte_regnum_p (gdbarch, regnum))
{ {
@ -832,7 +832,7 @@ amd64_return_value (struct gdbarch *gdbarch, struct value *function,
if (read_value != nullptr) if (read_value != nullptr)
{ {
*read_value = value::allocate (type); *read_value = value::allocate (type);
readbuf = value_contents_raw (*read_value).data (); readbuf = (*read_value)->contents_raw ().data ();
} }
/* 8. If the class is COMPLEX_X87, the real part of the value is /* 8. If the class is COMPLEX_X87, the real part of the value is

2
gdb/amd64-windows-tdep.c
View file

@ -410,7 +410,7 @@ amd64_windows_return_value (struct gdbarch *gdbarch, struct value *function,
{ {
*read_value = value::allocate (type); *read_value = value::allocate (type);
regcache->raw_read_part (regnum, 0, len, regcache->raw_read_part (regnum, 0, len,
value_contents_raw (*read_value).data ()); (*read_value)->contents_raw ().data ());
} }
if (writebuf) if (writebuf)
regcache->raw_write_part (regnum, 0, len, writebuf); regcache->raw_write_part (regnum, 0, len, writebuf);

2
gdb/arch-utils.c
View file

@ -1179,7 +1179,7 @@ default_gdbarch_return_value
if (read_value != nullptr) if (read_value != nullptr)
{ {
*read_value = value::allocate (valtype); *read_value = value::allocate (valtype);
readbuf = value_contents_raw (*read_value).data (); readbuf = (*read_value)->contents_raw ().data ();
} }
return gdbarch->return_value (gdbarch, function, valtype, regcache, return gdbarch->return_value (gdbarch, function, valtype, regcache,

4
gdb/arm-tdep.c
View file

@ -9193,7 +9193,7 @@ arm_return_value (struct gdbarch *gdbarch, struct value *function,
if (read_value != nullptr) if (read_value != nullptr)
{ {
*read_value = value::allocate (valtype); *read_value = value::allocate (valtype);
readbuf = value_contents_raw (*read_value).data (); readbuf = (*read_value)->contents_raw ().data ();
} }
for (i = 0; i < vfp_base_count; i++) for (i = 0; i < vfp_base_count; i++)
@ -9269,7 +9269,7 @@ arm_return_value (struct gdbarch *gdbarch, struct value *function,
if (read_value != nullptr) if (read_value != nullptr)
{ {
*read_value = value::allocate (valtype); *read_value = value::allocate (valtype);
gdb_byte *readbuf = value_contents_raw (*read_value).data (); gdb_byte *readbuf = (*read_value)->contents_raw ().data ();
arm_extract_return_value (valtype, regcache, readbuf); arm_extract_return_value (valtype, regcache, readbuf);
} }

2
gdb/c-lang.c
View file

@ -674,7 +674,7 @@ c_string_operation::evaluate (struct type *expect_type,
error (_("Too many array elements")); error (_("Too many array elements"));
result = value::allocate (expect_type); result = value::allocate (expect_type);
memcpy (value_contents_raw (result).data (), obstack_base (&output), memcpy (result->contents_raw ().data (), obstack_base (&output),
obstack_object_size (&output)); obstack_object_size (&output));
} }
else else

2
gdb/cp-valprint.c
View file

@ -762,7 +762,7 @@ test_print_fields (gdbarch *arch)
} }
value *val = value::allocate (the_struct); value *val = value::allocate (the_struct);
gdb_byte *contents = value_contents_writeable (val).data (); gdb_byte *contents = val->contents_writeable ().data ();
store_unsigned_integer (contents, val->enclosing_type ()->length (), store_unsigned_integer (contents, val->enclosing_type ()->length (),
gdbarch_byte_order (arch), 0xe9); gdbarch_byte_order (arch), 0xe9);

2
gdb/dummy-frame.c
View file

@ -354,7 +354,7 @@ dummy_frame_prev_register (frame_info_ptr this_frame,
constructs either a raw or pseudo register from the raw constructs either a raw or pseudo register from the raw
register cache. */ register cache. */
cache->prev_regcache->cooked_read cache->prev_regcache->cooked_read
(regnum, value_contents_writeable (reg_val).data ()); (regnum, reg_val->contents_writeable ().data ());
return reg_val; return reg_val;
} }

6
gdb/dwarf2/expr.c
View file

@ -164,7 +164,7 @@ rw_pieced_value (value *v, value *from, bool check_optimized)
if (check_optimized) if (check_optimized)
v_contents = nullptr; v_contents = nullptr;
else else
v_contents = value_contents_raw (v).data (); v_contents = v->contents_raw ().data ();
from_contents = nullptr; from_contents = nullptr;
} }
@ -1026,7 +1026,7 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type,
subobj_offset += n - max; subobj_offset += n - max;
copy (value_contents_all (val).slice (subobj_offset, len), copy (value_contents_all (val).slice (subobj_offset, len),
value_contents_raw (retval)); retval->contents_raw ());
} }
break; break;
@ -1038,7 +1038,7 @@ dwarf_expr_context::fetch_result (struct type *type, struct type *subobj_type,
invalid_synthetic_pointer (); invalid_synthetic_pointer ();
retval = value::allocate (subobj_type); retval = value::allocate (subobj_type);
bfd_byte *contents = value_contents_raw (retval).data (); bfd_byte *contents = retval->contents_raw ().data ();
memcpy (contents, this->m_data + subobj_offset, n); memcpy (contents, this->m_data + subobj_offset, n);
} }
break; break;

4
gdb/dwarf2/loc.c
View file

@ -1363,8 +1363,8 @@ value_of_dwarf_reg_entry (struct type *type, frame_info_ptr frame,
release_value (target_val).release ()); release_value (target_val).release ());
/* Copy the referencing pointer to the new computed value. */ /* Copy the referencing pointer to the new computed value. */
memcpy (value_contents_raw (val).data (), memcpy (val->contents_raw ().data (),
value_contents_raw (outer_val).data (), outer_val->contents_raw ().data (),
checked_type->length ()); checked_type->length ());
val->set_lazy (0); val->set_lazy (0);

2
gdb/dwarf2/read.c
View file

@ -8992,7 +8992,7 @@ dwarf2_compute_name (const char *name,
else if (bytes != NULL) else if (bytes != NULL)
{ {
v = value::allocate (type); v = value::allocate (type);
memcpy (value_contents_writeable (v).data (), bytes, memcpy (v->contents_writeable ().data (), bytes,
type->length ()); type->length ());
} }
else else

10
gdb/eval.c
View file

@ -2413,7 +2413,7 @@ array_operation::evaluate_struct_tuple (struct value *struct_val,
bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno); bitsize = TYPE_FIELD_BITSIZE (struct_type, fieldno);
bitpos = struct_type->field (fieldno).loc_bitpos (); bitpos = struct_type->field (fieldno).loc_bitpos ();
addr = value_contents_writeable (struct_val).data () + bitpos / 8; addr = struct_val->contents_writeable ().data () + bitpos / 8;
if (bitsize) if (bitsize)
modify_field (struct_type, addr, modify_field (struct_type, addr,
value_as_long (val), bitpos % 8, bitsize); value_as_long (val), bitpos % 8, bitsize);
@ -2442,7 +2442,7 @@ array_operation::evaluate (struct type *expect_type,
{ {
struct value *rec = value::allocate (expect_type); struct value *rec = value::allocate (expect_type);
memset (value_contents_raw (rec).data (), '\0', type->length ()); memset (rec->contents_raw ().data (), '\0', type->length ());
return evaluate_struct_tuple (rec, exp, noside, nargs); return evaluate_struct_tuple (rec, exp, noside, nargs);
} }
@ -2461,7 +2461,7 @@ array_operation::evaluate (struct type *expect_type,
high_bound = (type->length () / element_size) - 1; high_bound = (type->length () / element_size) - 1;
} }
index = low_bound; index = low_bound;
memset (value_contents_raw (array).data (), 0, expect_type->length ()); memset (array->contents_raw ().data (), 0, expect_type->length ());
for (tem = nargs; --nargs >= 0;) for (tem = nargs; --nargs >= 0;)
{ {
struct value *element; struct value *element;
@ -2473,7 +2473,7 @@ array_operation::evaluate (struct type *expect_type,
if (index > high_bound) if (index > high_bound)
/* To avoid memory corruption. */ /* To avoid memory corruption. */
error (_("Too many array elements")); error (_("Too many array elements"));
memcpy (value_contents_raw (array).data () memcpy (array->contents_raw ().data ()
+ (index - low_bound) * element_size, + (index - low_bound) * element_size,
value_contents (element).data (), value_contents (element).data (),
element_size); element_size);
@ -2486,7 +2486,7 @@ array_operation::evaluate (struct type *expect_type,
&& type->code () == TYPE_CODE_SET) && type->code () == TYPE_CODE_SET)
{ {
struct value *set = value::allocate (expect_type); struct value *set = value::allocate (expect_type);
gdb_byte *valaddr = value_contents_raw (set).data (); gdb_byte *valaddr = set->contents_raw ().data ();
struct type *element_type = type->index_type (); struct type *element_type = type->index_type ();
struct type *check_type = element_type; struct type *check_type = element_type;
LONGEST low_bound, high_bound; LONGEST low_bound, high_bound;

6
gdb/findvar.c
View file

@ -587,7 +587,7 @@ language_defn::read_var_value (struct symbol *var,
} }
/* Put the constant back in target format. */ /* Put the constant back in target format. */
v = value::allocate (type); v = value::allocate (type);
store_signed_integer (value_contents_raw (v).data (), type->length (), store_signed_integer (v->contents_raw ().data (), type->length (),
type_byte_order (type), var->value_longest ()); type_byte_order (type), var->value_longest ());
VALUE_LVAL (v) = not_lval; VALUE_LVAL (v) = not_lval;
return v; return v;
@ -627,7 +627,7 @@ language_defn::read_var_value (struct symbol *var,
type = resolve_dynamic_type (type, {}, /* Unused address. */ 0); type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
} }
v = value::allocate (type); v = value::allocate (type);
memcpy (value_contents_raw (v).data (), var->value_bytes (), memcpy (v->contents_raw ().data (), var->value_bytes (),
type->length ()); type->length ());
VALUE_LVAL (v) = not_lval; VALUE_LVAL (v) = not_lval;
return v; return v;
@ -900,7 +900,7 @@ value_from_register (struct type *type, int regnum, frame_info_ptr frame)
VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame)); VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
VALUE_REGNUM (v) = regnum; VALUE_REGNUM (v) = regnum;
ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1, ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
value_contents_raw (v).data (), &optim, v->contents_raw ().data (), &optim,
&unavail); &unavail);
if (!ok) if (!ok)

6
gdb/frame-unwind.c
View file

@ -305,7 +305,7 @@ frame_unwind_got_constant (frame_info_ptr frame, int regnum,
struct value *reg_val; struct value *reg_val;
reg_val = value::zero (register_type (gdbarch, regnum), not_lval); reg_val = value::zero (register_type (gdbarch, regnum), not_lval);
store_unsigned_integer (value_contents_writeable (reg_val).data (), store_unsigned_integer (reg_val->contents_writeable ().data (),
register_size (gdbarch, regnum), byte_order, val); register_size (gdbarch, regnum), byte_order, val);
return reg_val; return reg_val;
} }
@ -317,7 +317,7 @@ frame_unwind_got_bytes (frame_info_ptr frame, int regnum, const gdb_byte *buf)
struct value *reg_val; struct value *reg_val;
reg_val = value::zero (register_type (gdbarch, regnum), not_lval); reg_val = value::zero (register_type (gdbarch, regnum), not_lval);
memcpy (value_contents_raw (reg_val).data (), buf, memcpy (reg_val->contents_raw ().data (), buf,
register_size (gdbarch, regnum)); register_size (gdbarch, regnum));
return reg_val; return reg_val;
} }
@ -334,7 +334,7 @@ frame_unwind_got_address (frame_info_ptr frame, int regnum,
struct value *reg_val; struct value *reg_val;
reg_val = value::zero (register_type (gdbarch, regnum), not_lval); reg_val = value::zero (register_type (gdbarch, regnum), not_lval);
pack_long (value_contents_writeable (reg_val).data (), pack_long (reg_val->contents_writeable ().data (),
register_type (gdbarch, regnum), addr); register_type (gdbarch, regnum), addr);
return reg_val; return reg_val;
} }

4
gdb/frame.c
View file

@ -1598,10 +1598,10 @@ put_frame_register_bytes (frame_info_ptr frame, int regnum,
regnum); regnum);
gdb_assert (value != NULL); gdb_assert (value != NULL);
memcpy ((char *) value_contents_writeable (value).data () + offset, memcpy ((char *) value->contents_writeable ().data () + offset,
myaddr, curr_len); myaddr, curr_len);
put_frame_register (frame, regnum, put_frame_register (frame, regnum,
value_contents_raw (value).data ()); value->contents_raw ().data ());
release_value (value); release_value (value);
} }

4
gdb/i386-tdep.c
View file

@ -3095,7 +3095,7 @@ i386_return_value (struct gdbarch *gdbarch, struct value *function,
{ {
*read_value = value::allocate (type); *read_value = value::allocate (type);
i386_extract_return_value (gdbarch, type, regcache, i386_extract_return_value (gdbarch, type, regcache,
value_contents_raw (*read_value).data ()); (*read_value)->contents_raw ().data ());
} }
if (writebuf) if (writebuf)
i386_store_return_value (gdbarch, type, regcache, writebuf); i386_store_return_value (gdbarch, type, regcache, writebuf);
@ -3379,7 +3379,7 @@ i386_pseudo_register_read_into_value (struct gdbarch *gdbarch,
{ {
gdb_byte raw_buf[I386_MAX_REGISTER_SIZE]; gdb_byte raw_buf[I386_MAX_REGISTER_SIZE];
enum register_status status; enum register_status status;
gdb_byte *buf = value_contents_raw (result_value).data (); gdb_byte *buf = result_value->contents_raw ().data ();
if (i386_mmx_regnum_p (gdbarch, regnum)) if (i386_mmx_regnum_p (gdbarch, regnum))
{ {

4
gdb/infrun.c
View file

@ -9143,7 +9143,7 @@ siginfo_value_read (struct value *v)
target_read (current_inferior ()->top_target (), target_read (current_inferior ()->top_target (),
TARGET_OBJECT_SIGNAL_INFO, TARGET_OBJECT_SIGNAL_INFO,
nullptr, nullptr,
value_contents_all_raw (v).data (), v->contents_all_raw ().data (),
v->offset (), v->offset (),
v->type ()->length ()); v->type ()->length ());
@ -9166,7 +9166,7 @@ siginfo_value_write (struct value *v, struct value *fromval)
transferred = target_write (current_inferior ()->top_target (), transferred = target_write (current_inferior ()->top_target (),
TARGET_OBJECT_SIGNAL_INFO, TARGET_OBJECT_SIGNAL_INFO,
nullptr, nullptr,
value_contents_all_raw (fromval).data (), fromval->contents_all_raw ().data (),
v->offset (), v->offset (),
fromval->type ()->length ()); fromval->type ()->length ());

12
gdb/opencl-lang.c
View file

@ -139,7 +139,7 @@ lval_func_read (struct value *v)
gdb_assert (n <= c->n); gdb_assert (n <= c->n);
for (i = offset; i < n; i++) for (i = offset; i < n; i++)
memcpy (value_contents_raw (v).data () + j++ * elsize, memcpy (v->contents_raw ().data () + j++ * elsize,
value_contents (c->val).data () + c->indices[i] * elsize, value_contents (c->val).data () + c->indices[i] * elsize,
elsize); elsize);
} }
@ -180,7 +180,7 @@ lval_func_write (struct value *v, struct value *fromval)
struct value *from_elm_val = value::allocate (eltype); struct value *from_elm_val = value::allocate (eltype);
struct value *to_elm_val = value_subscript (c->val, c->indices[i]); struct value *to_elm_val = value_subscript (c->val, c->indices[i]);
memcpy (value_contents_writeable (from_elm_val).data (), memcpy (from_elm_val->contents_writeable ().data (),
value_contents (fromval).data () + j++ * elsize, value_contents (fromval).data () + j++ * elsize,
elsize); elsize);
value_assign (to_elm_val, from_elm_val); value_assign (to_elm_val, from_elm_val);
@ -314,7 +314,7 @@ create_value (struct gdbarch *gdbarch, struct value *val, enum noside noside,
/* Copy src val contents into the destination value. */ /* Copy src val contents into the destination value. */
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
memcpy (value_contents_writeable (ret).data () memcpy (ret->contents_writeable ().data ()
+ (i * elm_type->length ()), + (i * elm_type->length ()),
value_contents (val).data () value_contents (val).data ()
+ (indices[i] * elm_type->length ()), + (indices[i] * elm_type->length ()),
@ -472,7 +472,7 @@ opencl_logical_not (struct type *expect_type, struct expression *exp,
value of its operand compares unequal to 0, and -1 (i.e. all bits value of its operand compares unequal to 0, and -1 (i.e. all bits
set) if the value of its operand compares equal to 0. */ set) if the value of its operand compares equal to 0. */
int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0; int tmp = value_logical_not (value_subscript (arg, i)) ? -1 : 0;
memset ((value_contents_writeable (ret).data () memset ((ret->contents_writeable ().data ()
+ i * eltype->length ()), + i * eltype->length ()),
tmp, eltype->length ()); tmp, eltype->length ());
} }
@ -573,7 +573,7 @@ vector_relop (struct expression *exp, struct value *val1, struct value *val2,
if the specified relation is true. */ if the specified relation is true. */
int tmp = scalar_relop (value_subscript (val1, i), int tmp = scalar_relop (value_subscript (val1, i),
value_subscript (val2, i), op) ? -1 : 0; value_subscript (val2, i), op) ? -1 : 0;
memset ((value_contents_writeable (ret).data () memset ((ret->contents_writeable ().data ()
+ i * eltype1->length ()), + i * eltype1->length ()),
tmp, eltype1->length ()); tmp, eltype1->length ());
} }
@ -837,7 +837,7 @@ Cannot perform conditional operation on vectors with different sizes"));
{ {
tmp = value_logical_not (value_subscript (arg1, i)) ? tmp = value_logical_not (value_subscript (arg1, i)) ?
value_subscript (arg3, i) : value_subscript (arg2, i); value_subscript (arg3, i) : value_subscript (arg2, i);
memcpy (value_contents_writeable (ret).data () + memcpy (ret->contents_writeable ().data () +
i * eltype2->length (), value_contents_all (tmp).data (), i * eltype2->length (), value_contents_all (tmp).data (),
eltype2->length ()); eltype2->length ());
} }

2
gdb/ppc-linux-tdep.c
View file

@ -255,7 +255,7 @@ ppc_linux_return_value (struct gdbarch *gdbarch, struct value *function,
if (read_value != nullptr) if (read_value != nullptr)
{ {
*read_value = value::allocate (valtype); *read_value = value::allocate (valtype);
readbuf = value_contents_raw (*read_value).data (); readbuf = (*read_value)->contents_raw ().data ();
} }
if ((valtype->code () == TYPE_CODE_STRUCT if ((valtype->code () == TYPE_CODE_STRUCT

4
gdb/regcache.c
View file

@ -716,7 +716,7 @@ readable_regcache::cooked_read (int regnum, gdb_byte *buf)
computed = gdbarch_pseudo_register_read_value (m_descr->gdbarch, computed = gdbarch_pseudo_register_read_value (m_descr->gdbarch,
this, regnum); this, regnum);
if (value_entirely_available (computed)) if (value_entirely_available (computed))
memcpy (buf, value_contents_raw (computed).data (), memcpy (buf, computed->contents_raw ().data (),
m_descr->sizeof_register[regnum]); m_descr->sizeof_register[regnum]);
else else
{ {
@ -751,7 +751,7 @@ readable_regcache::cooked_read_value (int regnum)
direction than in the other one, even though the value-based direction than in the other one, even though the value-based
API is preferred. */ API is preferred. */
if (cooked_read (regnum, if (cooked_read (regnum,
value_contents_raw (result).data ()) == REG_UNAVAILABLE) result->contents_raw ().data ()) == REG_UNAVAILABLE)
mark_value_bytes_unavailable (result, 0, mark_value_bytes_unavailable (result, 0,
result->type ()->length ()); result->type ()->length ());

8
gdb/riscv-tdep.c
View file

@ -3278,7 +3278,7 @@ riscv_return_value (struct gdbarch *gdbarch,
type_byte_order (arg_type), type_byte_order (arg_type),
arg_type->is_unsigned ()); arg_type->is_unsigned ());
abi_val = value::allocate (info.type); abi_val = value::allocate (info.type);
unscaled.write (value_contents_raw (abi_val), unscaled.write (abi_val->contents_raw (),
type_byte_order (info.type), type_byte_order (info.type),
info.type->is_unsigned ()); info.type->is_unsigned ());
} }
@ -3287,12 +3287,12 @@ riscv_return_value (struct gdbarch *gdbarch,
arg_val = value_from_contents (arg_type, writebuf); arg_val = value_from_contents (arg_type, writebuf);
abi_val = value_cast (info.type, arg_val); abi_val = value_cast (info.type, arg_val);
} }
writebuf = value_contents_raw (abi_val).data (); writebuf = abi_val->contents_raw ().data ();
} }
else else
{ {
abi_val = value::allocate (info.type); abi_val = value::allocate (info.type);
readbuf = value_contents_raw (abi_val).data (); readbuf = abi_val->contents_raw ().data ();
} }
arg_len = info.type->length (); arg_len = info.type->length ();
@ -3409,7 +3409,7 @@ riscv_return_value (struct gdbarch *gdbarch,
type_byte_order (info.type), type_byte_order (info.type),
info.type->is_unsigned ()); info.type->is_unsigned ());
*read_value = value::allocate (arg_type); *read_value = value::allocate (arg_type);
unscaled.write (value_contents_raw (*read_value), unscaled.write ((*read_value)->contents_raw (),
type_byte_order (arg_type), type_byte_order (arg_type),
arg_type->is_unsigned ()); arg_type->is_unsigned ());
} }

2
gdb/sparc-tdep.c
View file

@ -1531,7 +1531,7 @@ sparc32_return_value (struct gdbarch *gdbarch, struct value *function,
if (read_value != nullptr) if (read_value != nullptr)
{ {
*read_value = value::allocate (type); *read_value = value::allocate (type);
gdb_byte *readbuf = value_contents_raw (*read_value).data (); gdb_byte *readbuf = (*read_value)->contents_raw ().data ();
sparc32_extract_return_value (type, regcache, readbuf); sparc32_extract_return_value (type, regcache, readbuf);
} }
if (writebuf) if (writebuf)

4
gdb/std-regs.c
View file

@ -44,7 +44,7 @@ value_of_builtin_frame_fp_reg (frame_info_ptr frame, const void *baton)
{ {
struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr; struct type *data_ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
struct value *val = value::allocate (data_ptr_type); struct value *val = value::allocate (data_ptr_type);
gdb_byte *buf = value_contents_raw (val).data (); gdb_byte *buf = val->contents_raw ().data ();
gdbarch_address_to_pointer (gdbarch, data_ptr_type, gdbarch_address_to_pointer (gdbarch, data_ptr_type,
buf, get_frame_base_address (frame)); buf, get_frame_base_address (frame));
@ -63,7 +63,7 @@ value_of_builtin_frame_pc_reg (frame_info_ptr frame, const void *baton)
{ {
struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr; struct type *func_ptr_type = builtin_type (gdbarch)->builtin_func_ptr;
struct value *val = value::allocate (func_ptr_type); struct value *val = value::allocate (func_ptr_type);
gdb_byte *buf = value_contents_raw (val).data (); gdb_byte *buf = val->contents_raw ().data ();
gdbarch_address_to_pointer (gdbarch, func_ptr_type, gdbarch_address_to_pointer (gdbarch, func_ptr_type,
buf, get_frame_pc (frame)); buf, get_frame_pc (frame));

2
gdb/tracepoint.c
View file

@ -3778,7 +3778,7 @@ sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
type = init_vector_type (builtin_type (gdbarch)->builtin_true_char, type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
buf->size ()); buf->size ());
v = value::allocate (type); v = value::allocate (type);
memcpy (value_contents_raw (v).data (), buf->data (), buf->size ()); memcpy (v->contents_raw ().data (), buf->data (), buf->size ());
return v; return v;
} }
else else

20
gdb/valarith.c
View file

@ -717,7 +717,7 @@ value_concat (struct value *arg1, struct value *arg2)
lowbound + n_elts - 1); lowbound + n_elts - 1);
struct value *result = value::allocate (atype); struct value *result = value::allocate (atype);
gdb::array_view<gdb_byte> contents = value_contents_raw (result); gdb::array_view<gdb_byte> contents = result->contents_raw ();
gdb::array_view<const gdb_byte> lhs_contents = value_contents (arg1); gdb::array_view<const gdb_byte> lhs_contents = value_contents (arg1);
gdb::array_view<const gdb_byte> rhs_contents = value_contents (arg2); gdb::array_view<const gdb_byte> rhs_contents = value_contents (arg2);
gdb::copy (lhs_contents, contents.slice (0, lhs_contents.size ())); gdb::copy (lhs_contents, contents.slice (0, lhs_contents.size ()));
@ -872,7 +872,7 @@ fixed_point_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
value *fp_val = value::allocate (type1); value *fp_val = value::allocate (type1);
fp.write_fixed_point fp.write_fixed_point
(value_contents_raw (fp_val), (fp_val->contents_raw (),
type_byte_order (type1), type_byte_order (type1),
type1->is_unsigned (), type1->is_unsigned (),
type1->fixed_point_scaling_factor ()); type1->fixed_point_scaling_factor ());
@ -1191,7 +1191,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
v2.data (), &eff_type_v2); v2.data (), &eff_type_v2);
target_float_binop (op, v1.data (), eff_type_v1, target_float_binop (op, v1.data (), eff_type_v1,
v2.data (), eff_type_v2, v2.data (), eff_type_v2,
value_contents_raw (val).data (), result_type); val->contents_raw ().data (), result_type);
} }
else if (type1->code () == TYPE_CODE_BOOL else if (type1->code () == TYPE_CODE_BOOL
|| type2->code () == TYPE_CODE_BOOL) || type2->code () == TYPE_CODE_BOOL)
@ -1230,7 +1230,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
result_type = type1; result_type = type1;
val = value::allocate (result_type); val = value::allocate (result_type);
store_signed_integer (value_contents_raw (val).data (), store_signed_integer (val->contents_raw ().data (),
result_type->length (), result_type->length (),
type_byte_order (result_type), type_byte_order (result_type),
v); v);
@ -1376,7 +1376,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
} }
val = value::allocate (result_type); val = value::allocate (result_type);
store_unsigned_integer (value_contents_raw (val).data (), store_unsigned_integer (val->contents_raw ().data (),
val->type ()->length (), val->type ()->length (),
type_byte_order (result_type), type_byte_order (result_type),
v); v);
@ -1537,7 +1537,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
} }
val = value::allocate (result_type); val = value::allocate (result_type);
store_signed_integer (value_contents_raw (val).data (), store_signed_integer (val->contents_raw ().data (),
val->type ()->length (), val->type ()->length (),
type_byte_order (result_type), type_byte_order (result_type),
v); v);
@ -1582,7 +1582,7 @@ value_vector_widen (struct value *scalar_value, struct type *vector_type)
error (_("conversion of scalar to vector involves truncation")); error (_("conversion of scalar to vector involves truncation"));
value *val = value::allocate (vector_type); value *val = value::allocate (vector_type);
gdb::array_view<gdb_byte> val_contents = value_contents_writeable (val); gdb::array_view<gdb_byte> val_contents = val->contents_writeable ();
int elt_len = eltype->length (); int elt_len = eltype->length ();
for (i = 0; i < high_bound - low_bound + 1; i++) for (i = 0; i < high_bound - low_bound + 1; i++)
@ -1629,7 +1629,7 @@ vector_binop (struct value *val1, struct value *val2, enum exp_opcode op)
error (_("Cannot perform operation on vectors with different types")); error (_("Cannot perform operation on vectors with different types"));
value *val = value::allocate (type1); value *val = value::allocate (type1);
gdb::array_view<gdb_byte> val_contents = value_contents_writeable (val); gdb::array_view<gdb_byte> val_contents = val->contents_writeable ();
scoped_value_mark mark; scoped_value_mark mark;
for (i = 0; i < high_bound1 - low_bound1 + 1; i++) for (i = 0; i < high_bound1 - low_bound1 + 1; i++)
{ {
@ -1924,7 +1924,7 @@ value_neg (struct value *arg1)
if (!get_array_bounds (type, &low_bound, &high_bound)) if (!get_array_bounds (type, &low_bound, &high_bound))
error (_("Could not determine the vector bounds")); error (_("Could not determine the vector bounds"));
gdb::array_view<gdb_byte> val_contents = value_contents_writeable (val); gdb::array_view<gdb_byte> val_contents = val->contents_writeable ();
int elt_len = eltype->length (); int elt_len = eltype->length ();
for (i = 0; i < high_bound - low_bound + 1; i++) for (i = 0; i < high_bound - low_bound + 1; i++)
@ -1969,7 +1969,7 @@ value_complement (struct value *arg1)
error (_("Could not determine the vector bounds")); error (_("Could not determine the vector bounds"));
val = value::allocate (type); val = value::allocate (type);
gdb::array_view<gdb_byte> val_contents = value_contents_writeable (val); gdb::array_view<gdb_byte> val_contents = val->contents_writeable ();
int elt_len = eltype->length (); int elt_len = eltype->length ();
for (i = 0; i < high_bound - low_bound + 1; i++) for (i = 0; i < high_bound - low_bound + 1; i++)

32
gdb/valops.c
View file

@ -392,7 +392,7 @@ value_cast_to_fixed_point (struct type *to_type, struct value *from_val)
/* Finally, create the result value, and pack the unscaled value /* Finally, create the result value, and pack the unscaled value
in it. */ in it. */
struct value *result = value::allocate (to_type); struct value *result = value::allocate (to_type);
unscaled.write (value_contents_raw (result), unscaled.write (result->contents_raw (),
type_byte_order (to_type), type_byte_order (to_type),
to_type->is_unsigned ()); to_type->is_unsigned ());
@ -545,7 +545,7 @@ value_cast (struct type *type, struct value *arg2)
{ {
struct value *v = value::allocate (to_type); struct value *v = value::allocate (to_type);
target_float_convert (value_contents (arg2).data (), type2, target_float_convert (value_contents (arg2).data (), type2,
value_contents_raw (v).data (), type); v->contents_raw ().data (), type);
return v; return v;
} }
else if (is_fixed_point_type (type2)) else if (is_fixed_point_type (type2))
@ -558,7 +558,7 @@ value_cast (struct type *type, struct value *arg2)
type2->fixed_point_scaling_factor ()); type2->fixed_point_scaling_factor ());
struct value *v = value::allocate (to_type); struct value *v = value::allocate (to_type);
target_float_from_host_double (value_contents_raw (v).data (), target_float_from_host_double (v->contents_raw ().data (),
to_type, mpq_get_d (fp_val.val)); to_type, mpq_get_d (fp_val.val));
return v; return v;
} }
@ -621,7 +621,7 @@ value_cast (struct type *type, struct value *arg2)
struct value *result = value::allocate (to_type); struct value *result = value::allocate (to_type);
cplus_make_method_ptr (to_type, cplus_make_method_ptr (to_type,
value_contents_writeable (result).data (), 0, 0); result->contents_writeable ().data (), 0, 0);
return result; return result;
} }
else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
@ -955,7 +955,7 @@ value_one (struct type *type)
error (_("Could not determine the vector bounds")); error (_("Could not determine the vector bounds"));
val = value::allocate (type); val = value::allocate (type);
gdb::array_view<gdb_byte> val_contents = value_contents_writeable (val); gdb::array_view<gdb_byte> val_contents = val->contents_writeable ();
int elt_len = eltype->length (); int elt_len = eltype->length ();
for (i = 0; i < high_bound - low_bound + 1; i++) for (i = 0; i < high_bound - low_bound + 1; i++)
@ -1344,7 +1344,7 @@ value_assign (struct value *toval, struct value *fromval)
implies the returned value is not lazy, even if TOVAL was. */ implies the returned value is not lazy, even if TOVAL was. */
val = value_copy (toval); val = value_copy (toval);
val->set_lazy (0); val->set_lazy (0);
copy (value_contents (fromval), value_contents_raw (val)); copy (value_contents (fromval), val->contents_raw ());
/* We copy over the enclosing type and pointed-to offset from FROMVAL /* We copy over the enclosing type and pointed-to offset from FROMVAL
in the case of pointer types. For object types, the enclosing type in the case of pointer types. For object types, the enclosing type
@ -1377,7 +1377,7 @@ value_repeat (struct value *arg1, int count)
val->set_address (arg1->address ()); val->set_address (arg1->address ());
read_value_memory (val, 0, val->stack (), val->address (), read_value_memory (val, 0, val->stack (), val->address (),
value_contents_all_raw (val).data (), val->contents_all_raw ().data (),
type_length_units (val->enclosing_type ())); type_length_units (val->enclosing_type ()));
return val; return val;
@ -1750,7 +1750,7 @@ value_cstring (const char *ptr, ssize_t len, struct type *char_type)
= lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1); = lookup_array_range_type (char_type, lowbound, highbound + lowbound - 1);
val = value::allocate (stringtype); val = value::allocate (stringtype);
memcpy (value_contents_raw (val).data (), ptr, len); memcpy (val->contents_raw ().data (), ptr, len);
return val; return val;
} }
@ -1773,7 +1773,7 @@ value_string (const char *ptr, ssize_t len, struct type *char_type)
= lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1); = lookup_string_range_type (char_type, lowbound, highbound + lowbound - 1);
val = value::allocate (stringtype); val = value::allocate (stringtype);
memcpy (value_contents_raw (val).data (), ptr, len); memcpy (val->contents_raw ().data (), ptr, len);
return val; return val;
} }
@ -2101,7 +2101,7 @@ struct_field_searcher::search (struct value *arg1, LONGEST offset,
base_addr = arg1->address () + 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 (), v2->contents_raw ().data (),
v2->type ()->length ()) != 0) v2->type ()->length ()) != 0)
error (_("virtual baseclass botch")); error (_("virtual baseclass botch"));
} }
@ -3740,7 +3740,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
result = value::allocate result = value::allocate
(lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j))); (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 (), result->contents_writeable ().data (),
TYPE_FN_FIELD_VOFFSET (f, j), 1); TYPE_FN_FIELD_VOFFSET (f, j), 1);
} }
else if (noside == EVAL_AVOID_SIDE_EFFECTS) else if (noside == EVAL_AVOID_SIDE_EFFECTS)
@ -3765,7 +3765,7 @@ value_struct_elt_for_reference (struct type *domain, int offset,
{ {
result = value::allocate (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j))); result = value::allocate (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 (), result->contents_writeable ().data (),
v->address (), 0); v->address (), 0);
} }
} }
@ -4111,9 +4111,9 @@ value_literal_complex (struct value *arg1,
int len = real_type->length (); int len = real_type->length ();
copy (value_contents (arg1), copy (value_contents (arg1),
value_contents_raw (val).slice (0, len)); val->contents_raw ().slice (0, len));
copy (value_contents (arg2), copy (value_contents (arg2),
value_contents_raw (val).slice (len, len)); val->contents_raw ().slice (len, len));
return val; return val;
} }
@ -4158,9 +4158,9 @@ cast_into_complex (struct type *type, struct value *val)
int len = val_real_type->length (); int len = val_real_type->length ();
copy (value_contents (val).slice (0, len), copy (value_contents (val).slice (0, len),
value_contents_raw (re_val)); re_val->contents_raw ());
copy (value_contents (val).slice (len, len), copy (value_contents (val).slice (len, len),
value_contents_raw (im_val)); im_val->contents_raw ());
return value_literal_complex (re_val, im_val, type); return value_literal_complex (re_val, im_val, type);
} }

2
gdb/valprint.c
View file

@ -3100,7 +3100,7 @@ test_print_flags (gdbarch *arch)
append_flags_type_field (flags_type, 5, 3, field_type, "C"); append_flags_type_field (flags_type, 5, 3, field_type, "C");
value *val = value::allocate (flags_type); value *val = value::allocate (flags_type);
gdb_byte *contents = value_contents_writeable (val).data (); gdb_byte *contents = val->contents_writeable ().data ();
store_unsigned_integer (contents, 4, gdbarch_byte_order (arch), 0xaa); store_unsigned_integer (contents, 4, gdbarch_byte_order (arch), 0xaa);
string_file out; string_file out;

65
gdb/value.c
View file

@ -1023,25 +1023,24 @@ value::allocate_optimized_out (struct type *type)
/* Accessor methods. */ /* Accessor methods. */
gdb::array_view<gdb_byte> gdb::array_view<gdb_byte>
value_contents_raw (struct value *value) value::contents_raw ()
{ {
struct gdbarch *arch = value->arch (); int unit_size = gdbarch_addressable_memory_unit_size (arch ());
int unit_size = gdbarch_addressable_memory_unit_size (arch);
allocate_value_contents (value, true); allocate_value_contents (this, true);
ULONGEST length = value->type ()->length (); ULONGEST length = type ()->length ();
return gdb::make_array_view return gdb::make_array_view
(value->m_contents.get () + value->m_embedded_offset * unit_size, length); (m_contents.get () + m_embedded_offset * unit_size, length);
} }
gdb::array_view<gdb_byte> gdb::array_view<gdb_byte>
value_contents_all_raw (struct value *value) value::contents_all_raw ()
{ {
allocate_value_contents (value, true); allocate_value_contents (this, true);
ULONGEST length = value->enclosing_type ()->length (); ULONGEST length = enclosing_type ()->length ();
return gdb::make_array_view (value->m_contents.get (), length); return gdb::make_array_view (m_contents.get (), length);
} }
/* Look at value.h for description. */ /* Look at value.h for description. */
@ -1215,10 +1214,10 @@ value_contents_copy_raw (struct value *dst, LONGEST dst_offset,
/* Copy the data. */ /* Copy the data. */
gdb::array_view<gdb_byte> dst_contents gdb::array_view<gdb_byte> dst_contents
= value_contents_all_raw (dst).slice (dst_offset * unit_size, = dst->contents_all_raw ().slice (dst_offset * unit_size,
length * unit_size); length * unit_size);
gdb::array_view<const gdb_byte> src_contents gdb::array_view<const gdb_byte> src_contents
= value_contents_all_raw (src).slice (src_offset * unit_size, = src->contents_all_raw ().slice (src_offset * unit_size,
length * unit_size); length * unit_size);
copy (src_contents, dst_contents); copy (src_contents, dst_contents);
@ -1256,8 +1255,8 @@ value_contents_copy_raw_bitwise (struct value *dst, LONGEST dst_bit_offset,
bit_length)); bit_length));
/* Copy the data. */ /* Copy the data. */
gdb::array_view<gdb_byte> dst_contents = value_contents_all_raw (dst); gdb::array_view<gdb_byte> dst_contents = dst->contents_all_raw ();
gdb::array_view<const gdb_byte> src_contents = value_contents_all_raw (src); gdb::array_view<const gdb_byte> src_contents = src->contents_all_raw ();
copy_bitwise (dst_contents.data (), dst_bit_offset, copy_bitwise (dst_contents.data (), dst_bit_offset,
src_contents.data (), src_bit_offset, src_contents.data (), src_bit_offset,
bit_length, bit_length,
@ -1292,18 +1291,18 @@ value_contents_copy (struct value *dst, LONGEST dst_offset,
gdb::array_view<const gdb_byte> gdb::array_view<const gdb_byte>
value_contents (struct value *value) value_contents (struct value *value)
{ {
gdb::array_view<const gdb_byte> result = value_contents_writeable (value); gdb::array_view<const gdb_byte> result = value->contents_writeable ();
require_not_optimized_out (value); require_not_optimized_out (value);
require_available (value); require_available (value);
return result; return result;
} }
gdb::array_view<gdb_byte> gdb::array_view<gdb_byte>
value_contents_writeable (struct value *value) value::contents_writeable ()
{ {
if (value->m_lazy) if (m_lazy)
value_fetch_lazy (value); value_fetch_lazy (this);
return value_contents_raw (value); return contents_raw ();
} }
int int
@ -1577,7 +1576,7 @@ value_copy (const value *arg)
allocate_value_contents (val, false); allocate_value_contents (val, false);
gdb::array_view<gdb_byte> val_contents gdb::array_view<gdb_byte> val_contents
= value_contents_all_raw (val).slice (0, length); = val->contents_all_raw ().slice (0, length);
copy (arg_view, val_contents); copy (arg_view, val_contents);
} }
@ -1621,7 +1620,7 @@ value_non_lval (struct value *arg)
struct type *enc_type = arg->enclosing_type (); struct type *enc_type = arg->enclosing_type ();
struct value *val = value::allocate (enc_type); struct value *val = value::allocate (enc_type);
copy (value_contents_all (arg), value_contents_all_raw (val)); copy (value_contents_all (arg), val->contents_all_raw ());
val->m_type = arg->m_type; val->m_type = arg->m_type;
val->set_embedded_offset (arg->embedded_offset ()); val->set_embedded_offset (arg->embedded_offset ());
val->set_pointed_to_offset (arg->pointed_to_offset ()); val->set_pointed_to_offset (arg->pointed_to_offset ());
@ -1637,7 +1636,7 @@ value_force_lval (struct value *v, CORE_ADDR addr)
{ {
gdb_assert (VALUE_LVAL (v) == not_lval); gdb_assert (VALUE_LVAL (v) == not_lval);
write_memory (addr, value_contents_raw (v).data (), v->type ()->length ()); write_memory (addr, v->contents_raw ().data (), v->type ()->length ());
v->m_lval = lval_memory; v->m_lval = lval_memory;
v->m_location.address = addr; v->m_location.address = addr;
} }
@ -2190,15 +2189,15 @@ set_internalvar_component (struct internalvar *var,
LONGEST bitsize, struct value *newval) LONGEST bitsize, struct value *newval)
{ {
gdb_byte *addr; gdb_byte *addr;
struct gdbarch *arch; struct gdbarch *gdbarch;
int unit_size; int unit_size;
switch (var->kind) switch (var->kind)
{ {
case INTERNALVAR_VALUE: case INTERNALVAR_VALUE:
addr = value_contents_writeable (var->u.value).data (); addr = var->u.value->contents_writeable ().data ();
arch = var->u.value->arch (); gdbarch = var->u.value->arch ();
unit_size = gdbarch_addressable_memory_unit_size (arch); unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
if (bitsize) if (bitsize)
modify_field (var->u.value->type (), addr + offset, modify_field (var->u.value->type (), addr + offset,
@ -3231,7 +3230,7 @@ unpack_value_bitfield (struct value *dest_val,
num = unpack_bits_as_long (field_type, valaddr + embedded_offset, num = unpack_bits_as_long (field_type, valaddr + embedded_offset,
bitpos, bitsize); bitpos, bitsize);
store_signed_integer (value_contents_raw (dest_val).data (), store_signed_integer (dest_val->contents_raw ().data (),
field_type->length (), byte_order, num); field_type->length (), byte_order, num);
} }
@ -3437,7 +3436,7 @@ value_from_longest (struct type *type, LONGEST num)
{ {
struct value *val = value::allocate (type); struct value *val = value::allocate (type);
pack_long (value_contents_raw (val).data (), type, num); pack_long (val->contents_raw ().data (), type, num);
return val; return val;
} }
@ -3449,7 +3448,7 @@ value_from_ulongest (struct type *type, ULONGEST num)
{ {
struct value *val = value::allocate (type); struct value *val = value::allocate (type);
pack_unsigned_long (value_contents_raw (val).data (), type, num); pack_unsigned_long (val->contents_raw ().data (), type, num);
return val; return val;
} }
@ -3463,7 +3462,7 @@ value_from_pointer (struct type *type, CORE_ADDR addr)
{ {
struct value *val = value::allocate (type); struct value *val = value::allocate (type);
store_typed_address (value_contents_raw (val).data (), store_typed_address (val->contents_raw ().data (),
check_typedef (type), addr); check_typedef (type), addr);
return val; return val;
} }
@ -3477,7 +3476,7 @@ value_from_host_double (struct type *type, double d)
{ {
struct value *value = value::allocate (type); struct value *value = value::allocate (type);
gdb_assert (type->code () == TYPE_CODE_FLT); gdb_assert (type->code () == TYPE_CODE_FLT);
target_float_from_host_double (value_contents_raw (value).data (), target_float_from_host_double (value->contents_raw ().data (),
value->type (), d); value->type (), d);
return value; return value;
} }
@ -3543,7 +3542,7 @@ value_from_contents (struct type *type, const gdb_byte *contents)
struct value *result; struct value *result;
result = value::allocate (type); result = value::allocate (type);
memcpy (value_contents_raw (result).data (), contents, type->length ()); memcpy (result->contents_raw ().data (), contents, type->length ());
return result; return result;
} }
@ -3837,7 +3836,7 @@ value_fetch_lazy_memory (struct value *val)
if (len > 0) if (len > 0)
read_value_memory (val, 0, val->stack (), addr, read_value_memory (val, 0, val->stack (), addr,
value_contents_all_raw (val).data (), len); val->contents_all_raw ().data (), len);
} }
/* Helper for value_fetch_lazy when the value is in a register. */ /* Helper for value_fetch_lazy when the value is in a register. */

34
gdb/value.h
View file

@ -370,6 +370,22 @@ public:
int *deprecated_regnum_hack (); int *deprecated_regnum_hack ();
/* contents() and contents_raw() both return the address of the gdb
buffer used to hold a copy of the contents of the lval.
contents() is used when the contents of the buffer are needed --
it uses fetch_lazy() to load the buffer from the process being
debugged if it hasn't already been loaded (contents_writeable()
is used when a writeable but fetched buffer is required)..
contents_raw() is used when data is being stored into the buffer,
or when it is certain that the contents of the buffer are valid.
Note: The contents pointer is adjusted by the offset required to
get to the real subobject, if the value happens to represent
something embedded in a larger run-time object. */
gdb::array_view<gdb_byte> contents_raw ();
gdb::array_view<gdb_byte> contents_all_raw ();
gdb::array_view<gdb_byte> contents_writeable ();
/* 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. */
@ -636,22 +652,6 @@ struct lval_funcs
extern void error_value_optimized_out (void); extern void error_value_optimized_out (void);
/* value_contents() and value_contents_raw() both return the address
of the gdb buffer used to hold a copy of the contents of the lval.
value_contents() is used when the contents of the buffer are needed
-- it uses value_fetch_lazy() to load the buffer from the process
being debugged if it hasn't already been loaded
(value_contents_writeable() is used when a writeable but fetched
buffer is required).. value_contents_raw() is used when data is
being stored into the buffer, or when it is certain that the
contents of the buffer are valid.
Note: The contents pointer is adjusted by the offset required to
get to the real subobject, if the value happens to represent
something embedded in a larger run-time object. */
extern gdb::array_view<gdb_byte> value_contents_raw (struct value *);
/* Actual contents of the value. For use of this value; setting it /* Actual contents of the value. For use of this value; setting it
uses the stuff above. Not valid if lazy is nonzero. Target uses the stuff above. Not valid if lazy is nonzero. Target
byte-order. We force it to be aligned properly for any possible byte-order. We force it to be aligned properly for any possible
@ -659,12 +659,10 @@ extern gdb::array_view<gdb_byte> value_contents_raw (struct value *);
declared here. */ declared here. */
extern gdb::array_view<const gdb_byte> value_contents (struct value *); extern gdb::array_view<const gdb_byte> value_contents (struct value *);
extern gdb::array_view<gdb_byte> value_contents_writeable (struct value *);
/* The ALL variants of the above two macros do not adjust the returned /* The ALL variants of the above two macros do not adjust the returned
pointer by the embedded_offset value. */ pointer by the embedded_offset value. */
extern gdb::array_view<gdb_byte> value_contents_all_raw (struct value *);
extern gdb::array_view<const gdb_byte> value_contents_all (struct value *); extern gdb::array_view<const gdb_byte> value_contents_all (struct value *);
/* Like value_contents_all, but does not require that the returned /* Like value_contents_all, but does not require that the returned

2
gdb/windows-tdep.c
View file

@ -404,7 +404,7 @@ tlb_value_read (struct value *val)
if (!target_get_tib_address (inferior_ptid, &tlb)) if (!target_get_tib_address (inferior_ptid, &tlb))
error (_("Unable to read tlb")); error (_("Unable to read tlb"));
store_typed_address (value_contents_raw (val).data (), type, tlb); store_typed_address (val->contents_raw ().data (), type, tlb);
} }
/* This function implements the lval_computed support for writing a /* This function implements the lval_computed support for writing a