34#include "gdbsupport/selftest.h"
40#if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
48template<
typename T,
typename>
52 typename std::make_unsigned<T>::type retval = 0;
54 if (buf.size () > (
int) sizeof (
T))
56That operation is not available on integers of more than %d bytes."),
61 if (byte_order == BFD_ENDIAN_BIG)
65 if (std::is_signed<T>::value)
68 retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
71 for (; i < buf.size (); ++i)
72 retval = (retval << 8) | buf[i];
76 ssize_t i = buf.size () - 1;
78 if (std::is_signed<T>::value)
81 retval = ((LONGEST) buf[i] ^ 0x80) - 0x80;
85 retval = (retval << 8) | buf[i];
92 enum bfd_endian byte_order);
94 (gdb::array_view<const gdb_byte> buf,
enum bfd_endian byte_order);
103 enum bfd_endian byte_order, LONGEST *pval)
106 const gdb_byte *first_addr;
110 if (byte_order == BFD_ENDIAN_BIG)
113 len > (int)
sizeof (LONGEST) && p < addr + orig_len;
126 for (p = addr + orig_len - 1;
127 len > (int)
sizeof (LONGEST) && p >= addr;
137 if (len <= (
int)
sizeof (LONGEST))
160template<
typename T,
typename>
166 gdb_byte *startaddr = addr;
167 gdb_byte *endaddr = startaddr + len;
171 if (byte_order == BFD_ENDIAN_BIG)
173 for (p = endaddr - 1; p >= startaddr; --p)
181 for (p = startaddr; p < endaddr; ++p)
191 enum bfd_endian byte_order,
195 enum bfd_endian byte_order,
215 int source_size,
bool is_signed,
216 enum bfd_endian byte_order)
218 signed int size_diff = dest_size - source_size;
222 if (byte_order == BFD_ENDIAN_BIG && size_diff > 0)
223 memcpy (dest + size_diff, source, source_size);
224 else if (byte_order == BFD_ENDIAN_BIG && size_diff < 0)
225 memcpy (dest, source - size_diff, dest_size);
227 memcpy (dest, source, std::min (source_size, dest_size));
234 gdb_byte extension = 0;
236 && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
237 || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
241 if (byte_order == BFD_ENDIAN_BIG)
242 memset (dest, extension, size_diff);
244 memset (dest + source_size, extension, size_diff);
256 struct value *reg_val;
276 struct value *reg_val;
281 gdb_assert (frame != NULL);
308 struct type *
type,
const gdb_byte *buf)
317 struct type *
type,
const gdb_byte *buf)
328 gdb_byte *buf, CORE_ADDR addr)
337 gdb_byte *buf, CORE_ADDR addr)
357 gdb_assert_not_reached (
"LOC_COMPUTED variable missing a method");
409 const struct block *frame_block = NULL;
418 else if (var_block == NULL)
437 while (frame != NULL && frame_block != var_block)
442 if (frame_block == NULL)
461 else if (frame_block->
function () !=
nullptr)
464 if (frame !=
nullptr)
467 if (frame_block ==
nullptr)
490 error (_(
"No frame is currently executing in block %s."),
493 error (_(
"No frame is currently executing in specified"
505 const struct block *var_block,
522 gdb_assert (frame != NULL);
524 error (_(
"Cannot read `%s' without registers"), var->
print_name ());
568 struct type *void_ptr_type
599 error (_(
"Unknown argument list address for `%s'."),
611 error (_(
"Unknown argument list address for `%s'."),
625 error (_(
"Cannot look up value of a typedef `%s'."),
643 struct value *regval;
652 error (_(
"Value of register variable not available for `%s'."),
662 error (_(
"Value of register variable not available for `%s'."),
670 gdb_assert_not_reached (
"LOC_COMPUTED variable missing a method");
681 bmsym = lookup_minimal_symbol (var->linkage_name (), nullptr,
685 return bmsym.minsym != nullptr;
692 if (bmsym.
minsym ==
nullptr)
694 const char *flavour_name
699 gdb_assert (flavour_name != NULL);
700 error (_(
"Missing %s symbol \"%s\"."),
727 error (_(
"Cannot look up value of a botched symbol `%s'."),
744 gdb_assert (lang != NULL);
841 int optim, unavail, ok;
891 if (regnum < 0 || regnum >= regnum_max_excl)
892 error (_(
"Invalid register #%d, expecting 0 <= # < %d"),
regnum,
906 gdb_byte *buf = (gdb_byte *) alloca (
type->
length ());
907 int optim, unavail, ok;
910 buf, &optim, &unavail);
943namespace findvar_tests {
954do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals,
int dest_size,
955 ULONGEST src_val,
int src_size)
957 for (
int i = 0; i < 2 ; i++)
959 gdb_byte srcbuf[
sizeof (ULONGEST)] = {};
960 gdb_byte destbuf[
sizeof (ULONGEST)] = {};
961 enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
965 memset (srcbuf, 0xaa,
sizeof (srcbuf));
972 memset (destbuf, 0xaa,
sizeof (destbuf));
979 memset (destbuf, 0xaa,
sizeof (destbuf));
988copy_integer_to_size_test ()
991 do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
992 do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
995 do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
996 do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
999 do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1000 do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1003 do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1005 do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1006 do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1008 do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1011 do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1012 do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1013 do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1014 do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1027 selftests::register_test
1028 (
"copy_integer_to_size",
1029 selftests::findvar_tests::copy_integer_to_size_test);
const struct block * get_frame_block(frame_info_ptr frame, CORE_ADDR *addr_in_block)
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)
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)
frame_info_ptr frame_follow_static_link(frame_info_ptr frame)
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)
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)
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)
struct type * resolve_dynamic_type(struct type *type, gdb::array_view< const gdb_byte > valaddr, CORE_ADDR addr, const frame_info_ptr *in_frame)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
unsigned int type_length_units(struct type *type)
struct type * check_typedef(struct type *type)
const struct language_defn * language_def(enum language lang)
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
bool is_static_block() const
symbol * function() const
bool is_global_block() 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
unrelocated_addr unrelocated_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
static struct value * allocate_optimized_out(struct type *type)
void contents_copy(struct value *dst, LONGEST dst_offset, LONGEST src_offset, LONGEST length)
void mark_bytes_optimized_out(int offset, int length)
static struct value * allocate(struct type *type)
void set_lval(lval_type val)
void mark_bytes_unavailable(LONGEST offset, ULONGEST length)
gdb::array_view< gdb_byte > contents_raw()
struct type * type() const
void set_offset(LONGEST offset)
enum lval_type lval() const
static struct value * allocate_lazy(struct type *type)
enum overlay_debugging_state overlay_debugging
CORE_ADDR symbol_overlayed_address(CORE_ADDR address, struct obj_section *section)
#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_lazy(struct type *type, CORE_ADDR addr, frame_info_ptr frame)
struct value * value_at(struct type *type, CORE_ADDR addr)
CORE_ADDR value_as_address(struct value *val)
void error_value_optimized_out(void)
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)