35#include "gdbsupport/selftest.h"
41#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
49template<
typename T,
typename>
53 typename std::make_unsigned<T>::type retval = 0;
55 if (buf.size () > (
int) sizeof (
T))
57That operation is not available on integers of more than %d bytes."),
62 if (byte_order == BFD_ENDIAN_BIG)
66 if (std::is_signed<T>::value)
69 retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
72 for (; i < buf.size (); ++i)
73 retval = (retval << 8) | buf[i];
77 ssize_t i = buf.size () - 1;
79 if (std::is_signed<T>::value)
82 retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
86 retval = (retval << 8) | buf[i];
93 enum bfd_endian byte_order);
95 (gdb::array_view<const gdb_byte> buf,
enum bfd_endian byte_order);
104 enum bfd_endian byte_order, LONGEST *pval)
107 const gdb_byte *first_addr;
111 if (byte_order == BFD_ENDIAN_BIG)
114 len > (int)
sizeof (LONGEST) && p < addr + orig_len;
127 for (p = addr + orig_len - 1;
128 len > (int)
sizeof (LONGEST) && p >= addr;
138 if (len <= (
int)
sizeof (LONGEST))
161template<
typename T,
typename>
167 gdb_byte *startaddr = addr;
168 gdb_byte *endaddr = startaddr + len;
172 if (byte_order == BFD_ENDIAN_BIG)
174 for (p = endaddr - 1; p >= startaddr; --p)
182 for (p = startaddr; p < endaddr; ++p)
192 enum bfd_endian byte_order,
196 enum bfd_endian byte_order,
216 int source_size,
bool is_signed,
217 enum bfd_endian byte_order)
219 signed int size_diff = dest_size - source_size;
223 if (byte_order == BFD_ENDIAN_BIG && size_diff > 0)
224 memcpy (dest + size_diff, source, source_size);
225 else if (byte_order == BFD_ENDIAN_BIG && size_diff < 0)
226 memcpy (dest, source - size_diff, dest_size);
228 memcpy (dest, source, std::min (source_size, dest_size));
235 gdb_byte extension = 0;
237 && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
238 || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
242 if (byte_order == BFD_ENDIAN_BIG)
243 memset (dest, extension, size_diff);
245 memset (dest + source_size, extension, size_diff);
257 struct value *reg_val;
277 struct value *reg_val;
282 gdb_assert (frame != NULL);
309 struct type *
type,
const gdb_byte *buf)
318 struct type *
type,
const gdb_byte *buf)
329 gdb_byte *buf, CORE_ADDR addr)
338 gdb_byte *buf, CORE_ADDR addr)
358 gdb_assert_not_reached (
"LOC_COMPUTED variable missing a method");
402 CORE_ADDR upper_frame_base;
418 if (framefunc != NULL
422 == upper_frame_base))
445 const struct block *frame_block = NULL;
454 else if (var_block == NULL)
474 while (frame != NULL && frame_block != var_block)
479 if (frame_block == NULL)
502 int could_climb_up = 0;
504 if (static_link != NULL)
510 could_climb_up = frame_block != NULL;
538 error (_(
"No frame is currently executing in block %s."),
541 error (_(
"No frame is currently executing in specified"
553 const struct block *var_block,
570 gdb_assert (frame != NULL);
572 error (_(
"Cannot read `%s' without registers"), var->
print_name ());
616 struct type *void_ptr_type
647 error (_(
"Unknown argument list address for `%s'."),
659 error (_(
"Unknown argument list address for `%s'."),
673 error (_(
"Cannot look up value of a typedef `%s'."),
691 struct value *regval;
700 error (_(
"Value of register variable not available for `%s'."),
710 error (_(
"Value of register variable not available for `%s'."),
718 gdb_assert_not_reached (
"LOC_COMPUTED variable missing a method");
729 bmsym = lookup_minimal_symbol (var->linkage_name (), nullptr,
733 return bmsym.minsym != nullptr;
740 if (bmsym.
minsym ==
nullptr)
742 const char *flavour_name
747 gdb_assert (flavour_name != NULL);
748 error (_(
"Missing %s symbol \"%s\"."),
775 error (_(
"Cannot look up value of a botched symbol `%s'."),
792 gdb_assert (lang != NULL);
889 int optim, unavail, ok;
939 if (regnum < 0 || regnum >= regnum_max_excl)
940 error (_(
"Invalid register #%d, expecting 0 <= # < %d"),
regnum,
954 gdb_byte *buf = (gdb_byte *) alloca (
type->
length ());
955 int optim, unavail, ok;
958 buf, &optim, &unavail);
991namespace findvar_tests {
1002do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals,
int dest_size,
1003 ULONGEST src_val,
int src_size)
1005 for (
int i = 0; i < 2 ; i++)
1007 gdb_byte srcbuf[
sizeof (ULONGEST)] = {};
1008 gdb_byte destbuf[
sizeof (ULONGEST)] = {};
1009 enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
1013 memset (srcbuf, 0xaa,
sizeof (srcbuf));
1020 memset (destbuf, 0xaa,
sizeof (destbuf));
1027 memset (destbuf, 0xaa,
sizeof (destbuf));
1036copy_integer_to_size_test ()
1039 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1040 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1043 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1044 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1047 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1048 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1051 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1053 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1054 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1056 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1059 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1060 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1061 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1062 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1075 selftests::register_test
1076 (
"copy_integer_to_size",
1077 selftests::findvar_tests::copy_integer_to_size_test);
const struct block * block_global_block(const struct block *block)
int block_inlined_p(const struct block *bl)
struct dynamic_prop * block_static_link(const struct block *block)
const struct block * block_static_block(const struct block *block)
const struct block * get_frame_block(frame_info_ptr frame, CORE_ADDR *addr_in_block)
struct symbol * get_frame_function(frame_info_ptr frame)
frame_info_ptr block_innermost_frame(const struct block *block)
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void store_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, T val)
struct value * value_from_register(struct type *type, int regnum, frame_info_ptr frame)
CORE_ADDR unsigned_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
void address_to_signed_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
struct value * default_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
int symbol_read_needs_frame(struct symbol *sym)
struct value * value_of_register_lazy(frame_info_ptr frame, int regnum)
struct value * value_of_register(int regnum, frame_info_ptr frame)
CORE_ADDR signed_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
enum symbol_needs_kind symbol_read_needs(struct symbol *sym)
void store_typed_address(gdb_byte *buf, struct type *type, CORE_ADDR addr)
CORE_ADDR address_from_register(int regnum, frame_info_ptr frame)
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
void _initialize_findvar()
template LONGEST extract_integer< LONGEST >(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void read_frame_register_value(struct value *value, frame_info_ptr frame)
you lose T extract_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
static frame_info_ptr get_hosting_frame(struct symbol *var, const struct block *var_block, frame_info_ptr frame)
struct value * read_var_value(struct symbol *var, const struct block *var_block, frame_info_ptr frame)
void copy_integer_to_size(gdb_byte *dest, int dest_size, const gdb_byte *source, int source_size, bool is_signed, enum bfd_endian byte_order)
int extract_long_unsigned_integer(const gdb_byte *addr, int orig_len, enum bfd_endian byte_order, LONGEST *pval)
static frame_info_ptr follow_static_link(frame_info_ptr frame, const struct dynamic_prop *static_link)
template ULONGEST extract_integer< ULONGEST >(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
void unsigned_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
const struct frame_id null_frame_id
struct value * get_frame_register_value(frame_info_ptr frame, int regnum)
bool frame_id_p(frame_id l)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
enum frame_type get_frame_type(frame_info_ptr frame)
CORE_ADDR get_frame_args_address(frame_info_ptr fi)
CORE_ADDR get_frame_locals_address(frame_info_ptr fi)
frame_info_ptr frame_find_by_id(struct frame_id id)
struct frame_id get_frame_id(frame_info_ptr fi)
frame_info_ptr get_prev_frame(frame_info_ptr this_frame)
frame_info_ptr get_next_frame_sentinel_okay(frame_info_ptr this_frame)
CORE_ADDR get_frame_base(frame_info_ptr fi)
void gdbarch_iterate_over_objfiles_in_search_order(struct gdbarch *gdbarch, iterate_over_objfiles_in_search_order_cb_ftype cb, struct objfile *current_objfile)
CORE_ADDR gdbarch_pointer_to_address(struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf)
struct value * gdbarch_value_from_register(struct gdbarch *gdbarch, struct type *type, int regnum, struct frame_id frame_id)
int gdbarch_register_to_value(struct gdbarch *gdbarch, frame_info_ptr frame, int regnum, struct type *type, gdb_byte *buf, int *optimizedp, int *unavailablep)
void gdbarch_address_to_pointer(struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr)
int gdbarch_convert_register_p(struct gdbarch *gdbarch, int regnum, struct type *type)
static int gdbarch_num_cooked_regs(gdbarch *arch)
struct type * resolve_dynamic_type(struct type *type, gdb::array_view< const gdb_byte > valaddr, CORE_ADDR addr)
enum bfd_endian type_byte_order(const struct type *type)
struct type * lookup_pointer_type(struct type *type)
int is_dynamic_type(struct type *type)
unsigned int type_length_units(struct type *type)
struct type * check_typedef(struct type *type)
const struct language_defn * language_def(enum language lang)
bool dwarf2_evaluate_property(const struct dynamic_prop *prop, frame_info_ptr frame, const struct property_addr_info *addr_stack, CORE_ADDR *value, gdb::array_view< CORE_ADDR > push_values)
const char * objfile_flavour_name(struct objfile *objfile)
int register_size(struct gdbarch *gdbarch, int regnum)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
const block * superblock() const
CORE_ADDR entry_pc() const
symbol * function() const
CORE_ADDR value_address() const
struct minimal_symbol * minsym
struct type * builtin_func_ptr
struct type * builtin_data_ptr
const char * print_name() const
enum language language() const
struct obj_section * obj_section(const struct objfile *objfile) const
const char * linkage_name() const
virtual struct value * read_var_value(struct symbol *var, const struct block *var_block, frame_info_ptr frame) const
CORE_ADDR value_raw_address() const
struct bfd_section * the_bfd_section
const block * value_block() const
address_class aclass() const
struct type * type() const
LONGEST value_longest() const
const gdb_byte * value_bytes() const
CORE_ADDR value_address() const
struct objfile * objfile() const
bool is_pointer_or_reference() const
enum overlay_debugging_state overlay_debugging
CORE_ADDR symbol_overlayed_address(CORE_ADDR address, struct obj_section *section)
#define SYMBOL_BLOCK_OPS(symbol)
#define SYMBOL_COMPUTED_OPS(symbol)
#define SYMBOL_REGISTER_OPS(symbol)
int target_has_registers()
CORE_ADDR target_translate_tls_address(struct objfile *objfile, CORE_ADDR offset)
struct value * value_of_user_reg(int regnum, frame_info_ptr frame)
struct value * value_cast_pointers(struct type *type, struct value *arg2, int subclass_check)
struct value * value_at(struct type *type, CORE_ADDR addr)
struct value * value_at_lazy(struct type *type, CORE_ADDR addr)
struct type * value_type(const struct value *value)
struct value * allocate_value_lazy(struct type *type)
LONGEST value_offset(const struct value *value)
void value_contents_copy(struct value *dst, LONGEST dst_offset, struct value *src, LONGEST src_offset, LONGEST length)
struct value * allocate_value(struct type *type)
CORE_ADDR value_as_address(struct value *val)
void value_fetch_lazy(struct value *val)
void set_value_offset(struct value *value, LONGEST offset)
struct value * allocate_optimized_out_value(struct type *type)
void mark_value_bytes_unavailable(struct value *value, LONGEST offset, LONGEST length)
void error_value_optimized_out(void)
gdb::array_view< gdb_byte > value_contents_raw(struct value *value)
int value_optimized_out(struct value *value)
void mark_value_bytes_optimized_out(struct value *value, int offset, int length)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
value_ref_ptr release_value(struct value *val)
LONGEST unpack_long(struct type *type, const gdb_byte *valaddr)
#define VALUE_NEXT_FRAME_ID(val)
#define VALUE_REGNUM(val)