/* Find a variable's value in memory, for GDB, the GNU debugger.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
template<typename T, typename>
T
-extract_integer (const gdb_byte *addr, int len, enum bfd_endian byte_order)
+extract_integer (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order)
{
typename std::make_unsigned<T>::type retval = 0;
- const unsigned char *p;
- const unsigned char *startaddr = addr;
- const unsigned char *endaddr = startaddr + len;
- if (len > (int) sizeof (T))
+ if (buf.size () > (int) sizeof (T))
error (_("\
That operation is not available on integers of more than %d bytes."),
(int) sizeof (T));
the least significant. */
if (byte_order == BFD_ENDIAN_BIG)
{
- p = startaddr;
+ size_t i = 0;
+
if (std::is_signed<T>::value)
{
/* Do the sign extension once at the start. */
- retval = ((LONGEST) * p ^ 0x80) - 0x80;
- ++p;
+ retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
+ ++i;
}
- for (; p < endaddr; ++p)
- retval = (retval << 8) | *p;
+ for (; i < buf.size (); ++i)
+ retval = (retval << 8) | buf[i];
}
else
{
- p = endaddr - 1;
+ ssize_t i = buf.size () - 1;
+
if (std::is_signed<T>::value)
{
/* Do the sign extension once at the start. */
- retval = ((LONGEST) * p ^ 0x80) - 0x80;
- --p;
+ retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
+ --i;
}
- for (; p >= startaddr; --p)
- retval = (retval << 8) | *p;
+ for (; i >= 0; --i)
+ retval = (retval << 8) | buf[i];
}
return retval;
}
/* Explicit instantiations. */
-template LONGEST extract_integer<LONGEST> (const gdb_byte *addr, int len,
+template LONGEST extract_integer<LONGEST> (gdb::array_view<const gdb_byte> buf,
enum bfd_endian byte_order);
-template ULONGEST extract_integer<ULONGEST> (const gdb_byte *addr, int len,
- enum bfd_endian byte_order);
+template ULONGEST extract_integer<ULONGEST>
+ (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order);
/* Sometimes a long long unsigned integer can be extracted as a
LONGEST value. This is done so that we can print these values
CORE_ADDR
extract_typed_address (const gdb_byte *buf, struct type *type)
{
- if (type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
+ if (!type->is_pointer_or_reference ())
internal_error (__FILE__, __LINE__,
_("extract_typed_address: "
"type is not a pointer or reference"));
- return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
+ return gdbarch_pointer_to_address (type->arch (), type, buf);
}
/* All 'store' functions accept a host-format integer and store a
void
store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
{
- if (type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
+ if (!type->is_pointer_or_reference ())
internal_error (__FILE__, __LINE__,
_("store_typed_address: "
"type is not a pointer or reference"));
- gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
+ gdbarch_address_to_pointer (type->arch (), type, buf, addr);
}
/* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
next_frame = get_next_frame_sentinel_okay (frame);
+ /* In some cases NEXT_FRAME may not have a valid frame-id yet. This can
+ happen if we end up trying to unwind a register as part of the frame
+ sniffer. The only time that we get here without a valid frame-id is
+ if NEXT_FRAME is an inline frame. If this is the case then we can
+ avoid getting into trouble here by skipping past the inline frames. */
+ while (get_frame_type (next_frame) == INLINE_FRAME)
+ next_frame = get_next_frame_sentinel_okay (next_frame);
+
/* We should have a valid next frame. */
gdb_assert (frame_id_p (get_frame_id (next_frame)));
switch (SYMBOL_CLASS (sym))
{
/* All cases listed explicitly so that gcc -Wall will detect it if
- we failed to consider one. */
+ we failed to consider one. */
case LOC_COMPUTED:
- gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
+ gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
case LOC_REGISTER:
case LOC_ARG:
case LOC_LABEL:
/* Getting the address of a label can be done independently of the block,
- even if some *uses* of that address wouldn't work so well without
- the right frame. */
+ even if some *uses* of that address wouldn't work so well without
+ the right frame. */
case LOC_BLOCK:
case LOC_CONST_BYTES:
return frame;
}
-/* A default implementation for the "la_read_var_value" hook in
- the language vector which should work in most situations. */
+/* See language.h. */
struct value *
-default_read_var_value (struct symbol *var, const struct block *var_block,
- struct frame_info *frame)
+language_defn::read_var_value (struct symbol *var,
+ const struct block *var_block,
+ struct frame_info *frame) const
{
struct value *v;
struct type *type = SYMBOL_TYPE (var);
sym_need = symbol_read_needs (var);
if (sym_need == SYMBOL_NEEDS_FRAME)
gdb_assert (frame != NULL);
- else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers)
+ else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers ())
error (_("Cannot read `%s' without registers"), var->print_name ());
if (frame != NULL)
}
/* Put the constant back in target format. */
v = allocate_value (type);
- store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
+ store_signed_integer (value_contents_raw (v).data (), TYPE_LENGTH (type),
type_byte_order (type),
(LONGEST) SYMBOL_VALUE (var));
VALUE_LVAL (v) = not_lval;
v = allocate_value (type);
if (overlay_debugging)
{
- addr
- = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (symbol_objfile (var),
- var));
-
- store_typed_address (value_contents_raw (v), type, addr);
+ struct objfile *var_objfile = symbol_objfile (var);
+ addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
+ var->obj_section (var_objfile));
+ store_typed_address (value_contents_raw (v).data (), type, addr);
}
else
- store_typed_address (value_contents_raw (v), type,
+ store_typed_address (value_contents_raw (v).data (), type,
SYMBOL_VALUE_ADDRESS (var));
VALUE_LVAL (v) = not_lval;
return v;
type = resolve_dynamic_type (type, {}, /* Unused address. */ 0);
}
v = allocate_value (type);
- memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
+ memcpy (value_contents_raw (v).data (), SYMBOL_VALUE_BYTES (var),
TYPE_LENGTH (type));
VALUE_LVAL (v) = not_lval;
return v;
case LOC_STATIC:
if (overlay_debugging)
- addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
- SYMBOL_OBJ_SECTION (symbol_objfile (var),
- var));
+ addr
+ = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
+ var->obj_section (symbol_objfile (var)));
else
addr = SYMBOL_VALUE_ADDRESS (var);
break;
if (overlay_debugging)
addr = symbol_overlayed_address
(BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var)),
- SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
+ var->obj_section (symbol_objfile (var)));
else
addr = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (var));
break;
if (regval == NULL)
error (_("Value of register variable not available for `%s'."),
- var->print_name ());
+ var->print_name ());
addr = value_as_address (regval);
}
if (regval == NULL)
error (_("Value of register variable not available for `%s'."),
- var->print_name ());
+ var->print_name ());
return regval;
}
}
break;
case LOC_COMPUTED:
- gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
+ gdb_assert_not_reached ("LOC_COMPUTED variable missing a method");
case LOC_UNRESOLVED:
{
error (_("Missing %s symbol \"%s\"."),
flavour_name, var->linkage_name ());
}
- obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
+ obj_section = msym->obj_section (lookup_data.result.objfile);
/* Relocate address, unless there is no section or the variable is
a TLS variable. */
if (obj_section == NULL
return v;
}
-/* Calls VAR's language la_read_var_value hook with the given arguments. */
+/* Calls VAR's language read_var_value hook with the given arguments. */
struct value *
read_var_value (struct symbol *var, const struct block *var_block,
const struct language_defn *lang = language_def (var->language ());
gdb_assert (lang != NULL);
- gdb_assert (lang->la_read_var_value != NULL);
- return lang->la_read_var_value (var, var_block, frame);
+ return lang->read_var_value (var, var_block, frame);
}
/* Install default attributes for register values. */
struct value *
default_value_from_register (struct gdbarch *gdbarch, struct type *type,
- int regnum, struct frame_id frame_id)
+ int regnum, struct frame_id frame_id)
{
int len = TYPE_LENGTH (type);
struct value *value = allocate_value (type);
int reg_len = type_length_units (value_type (regval)) - reg_offset;
/* If the register length is larger than the number of bytes
- remaining to copy, then only copy the appropriate bytes. */
+ remaining to copy, then only copy the appropriate bytes. */
if (reg_len > len)
reg_len = len;
int optim, unavail, ok;
/* The ISA/ABI need to something weird when obtaining the
- specified value from this register. It might need to
- re-order non-adjacent, starting with REGNUM (see MIPS and
- i386). It might need to convert the [float] register into
- the corresponding [integer] type (see Alpha). The assumption
- is that gdbarch_register_to_value populates the entire value
- including the location. */
+ specified value from this register. It might need to
+ re-order non-adjacent, starting with REGNUM (see MIPS and
+ i386). It might need to convert the [float] register into
+ 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;
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), &optim,
+ value_contents_raw (v).data (), &optim,
&unavail);
if (!ok)
projects / binutils-gdb.git / blobdiff