/* Find a variable's value in memory, for GDB, the GNU debugger.
- Copyright (C) 1986-2022 Free Software Foundation, Inc.
+ Copyright (C) 1986-2023 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcore.h"
#include "inferior.h"
#include "target.h"
-#include "symfile.h" /* for overlay functions */
+#include "symfile.h"
#include "regcache.h"
#include "user-regs.h"
#include "block.h"
CORE_ADDR
extract_typed_address (const gdb_byte *buf, struct type *type)
{
- if (!type->is_pointer_or_reference ())
- internal_error (__FILE__, __LINE__,
- _("extract_typed_address: "
- "type is not a pointer or reference"));
-
+ gdb_assert (type->is_pointer_or_reference ());
return gdbarch_pointer_to_address (type->arch (), type, buf);
}
void
store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
{
- if (!type->is_pointer_or_reference ())
- internal_error (__FILE__, __LINE__,
- _("store_typed_address: "
- "type is not a pointer or reference"));
-
+ gdb_assert (type->is_pointer_or_reference ());
gdbarch_address_to_pointer (type->arch (), type, buf, addr);
}
return value_of_user_reg (regnum, frame);
reg_val = value_of_register_lazy (frame, regnum);
- value_fetch_lazy (reg_val);
+ reg_val->fetch_lazy ();
return reg_val;
}
/* We should have a valid next frame. */
gdb_assert (frame_id_p (get_frame_id (next_frame)));
- reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
- VALUE_LVAL (reg_val) = lval_register;
+ reg_val = value::allocate_lazy (register_type (gdbarch, regnum));
+ reg_val->set_lval (lval_register);
VALUE_REGNUM (reg_val) = regnum;
VALUE_NEXT_FRAME_ID (reg_val) = get_frame_id (next_frame);
tests that embed global/static symbols with null location lists.
We want to get <optimized out> instead of <frame required> when evaluating
them so return a frame instead of raising an error. */
- else if (var_block == block_global_block (var_block)
- || var_block == block_static_block (var_block))
+ else if (var_block->is_global_block () || var_block->is_static_block ())
return frame;
/* We have to handle the "my_func::my_local_var" notation. This requires us
/* If we failed to find the proper frame, fallback to the heuristic
method below. */
- else if (frame_block == block_global_block (frame_block))
+ else if (frame_block->is_global_block ())
{
frame = NULL;
break;
else if (frame_block->function ())
{
const struct dynamic_prop *static_link
- = block_static_link (frame_block);
+ = frame_block->static_link ();
int could_climb_up = 0;
if (static_link != NULL)
if (frame == NULL)
{
if (var_block->function ()
- && !block_inlined_p (var_block)
+ && !var_block->inlined_p ()
&& var_block->function ()->print_name ())
error (_("No frame is currently executing in block %s."),
var_block->function ()->print_name ());
type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
}
/* Put the constant back in target format. */
- v = allocate_value (type);
- store_signed_integer (value_contents_raw (v).data (), type->length (),
+ v = value::allocate (type);
+ store_signed_integer (v->contents_raw ().data (), type->length (),
type_byte_order (type), var->value_longest ());
- VALUE_LVAL (v) = not_lval;
+ v->set_lval (not_lval);
return v;
case LOC_LABEL:
- /* Put the constant back in target format. */
- v = allocate_value (type);
- if (overlay_debugging)
- {
- struct objfile *var_objfile = var->objfile ();
- addr = symbol_overlayed_address (var->value_address (),
- var->obj_section (var_objfile));
- store_typed_address (value_contents_raw (v).data (), type, addr);
- }
- else
- store_typed_address (value_contents_raw (v).data (), type,
- var->value_address ());
- VALUE_LVAL (v) = not_lval;
- return v;
+ {
+ /* Put the constant back in target format. */
+ if (overlay_debugging)
+ {
+ struct objfile *var_objfile = var->objfile ();
+ addr = symbol_overlayed_address (var->value_address (),
+ var->obj_section (var_objfile));
+ }
+ else
+ addr = var->value_address ();
+
+ /* First convert the CORE_ADDR to a function pointer type, this
+ ensures the gdbarch knows what type of pointer we are
+ manipulating when value_from_pointer is called. */
+ type = builtin_type (var->arch ())->builtin_func_ptr;
+ v = value_from_pointer (type, addr);
+
+ /* But we want to present the value as 'void *', so cast it to the
+ required type now, this will not change the values bit
+ representation. */
+ struct type *void_ptr_type
+ = builtin_type (var->arch ())->builtin_data_ptr;
+ v = value_cast_pointers (void_ptr_type, v, 0);
+ v->set_lval (not_lval);
+ return v;
+ }
case LOC_CONST_BYTES:
if (is_dynamic_type (type))
/* Value is a constant byte-sequence and needs no memory access. */
type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
}
- v = allocate_value (type);
- memcpy (value_contents_raw (v).data (), var->value_bytes (),
+ v = value::allocate (type);
+ memcpy (v->contents_raw ().data (), var->value_bytes (),
type->length ());
- VALUE_LVAL (v) = not_lval;
+ v->set_lval (not_lval);
return v;
case LOC_STATIC:
a TLS variable. */
if (obj_section == NULL
|| (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
- addr = bmsym.minsym->value_raw_address ();
+ addr = CORE_ADDR (bmsym.minsym->unrelocated_address ());
else
- addr = bmsym.value_address ();
+ addr = bmsym.value_address ();
if (overlay_debugging)
addr = symbol_overlayed_address (addr, obj_section);
/* Determine address of TLS variable. */
case LOC_OPTIMIZED_OUT:
if (is_dynamic_type (type))
type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
- return allocate_optimized_out_value (type);
+ return value::allocate_optimized_out (type);
default:
error (_("Cannot look up value of a botched symbol `%s'."),
int regnum, struct frame_id frame_id)
{
int len = type->length ();
- struct value *value = allocate_value (type);
+ struct value *value = value::allocate (type);
frame_info_ptr frame;
- VALUE_LVAL (value) = lval_register;
+ value->set_lval (lval_register);
frame = frame_find_by_id (frame_id);
if (frame == NULL)
if (type_byte_order (type) == BFD_ENDIAN_BIG
&& len < register_size (gdbarch, regnum))
/* Big-endian, and we want less than full size. */
- set_value_offset (value, register_size (gdbarch, regnum) - len);
+ value->set_offset (register_size (gdbarch, regnum) - len);
else
- set_value_offset (value, 0);
+ value->set_offset (0);
return value;
}
{
struct gdbarch *gdbarch = get_frame_arch (frame);
LONGEST offset = 0;
- LONGEST reg_offset = value_offset (value);
+ LONGEST reg_offset = value->offset ();
int regnum = VALUE_REGNUM (value);
- int len = type_length_units (check_typedef (value_type (value)));
+ int len = type_length_units (check_typedef (value->type ()));
- gdb_assert (VALUE_LVAL (value) == lval_register);
+ gdb_assert (value->lval () == lval_register);
/* Skip registers wholly inside of REG_OFFSET. */
while (reg_offset >= register_size (gdbarch, regnum))
while (len > 0)
{
struct value *regval = get_frame_register_value (frame, regnum);
- int reg_len = type_length_units (value_type (regval)) - reg_offset;
+ int reg_len = type_length_units (regval->type ()) - reg_offset;
/* If the register length is larger than the number of bytes
remaining to copy, then only copy the appropriate bytes. */
if (reg_len > len)
reg_len = len;
- value_contents_copy (value, offset, regval, reg_offset, reg_len);
+ regval->contents_copy (value, offset, reg_offset, reg_len);
offset += reg_len;
len -= reg_len;
the corresponding [integer] type (see Alpha). The assumption
is that gdbarch_register_to_value populates the entire value
including the location. */
- v = allocate_value (type);
- VALUE_LVAL (v) = lval_register;
+ v = value::allocate (type);
+ v->set_lval (lval_register);
VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
VALUE_REGNUM (v) = regnum;
ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
- value_contents_raw (v).data (), &optim,
+ v->contents_raw ().data (), &optim,
&unavail);
if (!ok)
{
if (optim)
- mark_value_bytes_optimized_out (v, 0, type->length ());
+ v->mark_bytes_optimized_out (0, type->length ());
if (unavail)
- mark_value_bytes_unavailable (v, 0, type->length ());
+ v->mark_bytes_unavailable (0, type->length ());
}
}
else
value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
read_frame_register_value (value, frame);
- if (value_optimized_out (value))
+ if (value->optimized_out ())
{
/* This function is used while computing a location expression.
Complain about the value being optimized out, rather than
projects / binutils-gdb.git / blobdiff