37#include <forward_list>
72#define MAX_PROC_NAME_SIZE sizeof("/proc/99999/lwp/9999/adi/lstatus")
76#define AT_ADI_BLKSZ 34
79#define AT_ADI_NBITS 35
82#define AT_ADI_UEONADI 36
140 return info.pid == pid;
169 fileio_error target_errno;
172 it = std::next (pit);
176 if ((*it).pid ==
pid)
178 if ((*it).stat.tag_fd > 0)
193 ULONGEST *addr, ULONGEST *endaddr)
195 const char *p = line;
197 *addr = strtoulst (p, &p, 16);
201 *endaddr = strtoulst (p, &p, 16);
213 if (
proc->stat.checked_avail)
214 return proc->stat.is_avail;
216 proc->stat.checked_avail =
true;
222 proc->stat.max_version = (1 <<
proc->stat.nbits) - 2;
223 proc->stat.is_avail =
true;
225 return proc->stat.is_avail;
238 addr &= ((uint64_t) -1) >> ast.
nbits;
241 CORE_ADDR signbit = (uint64_t) 1 << (64 - ast.
nbits - 1);
242 return (addr ^ signbit) - signbit;
283 if (
proc->stat.tag_fd != 0)
284 return proc->stat.tag_fd;
287 snprintf (cl_name,
sizeof(cl_name),
"/proc/%ld/adi/tags", (
long)
pid);
288 fileio_error target_errno;
290 false, 0, &target_errno);
291 return proc->stat.tag_fd;
305 snprintf (filename,
sizeof filename,
"/proc/%ld/adi/maps", (
long)
pid);
306 gdb::unique_xmalloc_ptr<char> data
312 for (
char *line = strtok_r (data.get (),
"\n", &saveptr);
314 line = strtok_r (NULL,
"\n", &saveptr))
316 ULONGEST addr, endaddr;
320 while (((vaddr + i) * adi_stat.
blksize) >= addr
321 && ((vaddr + i) * adi_stat.
blksize) < endaddr)
329 warning (_(
"unable to open /proc file '%s'"), filename);
347 error(_(
"Address at %s is not in ADI maps"),
351 fileio_error target_errno;
368 error(_(
"Address at %s is not in ADI maps"),
372 fileio_error target_errno;
383 const int maxelts = 8;
392 for (
int i = maxelts; i > 0 && cnt > 0; i--, cnt--)
394 if (tags[v_idx] == 0xff)
414 gdb::def_vector<gdb_byte> buf (cnt);
417 error (_(
"No ADI information"));
418 else if (read_cnt < cnt)
431 std::vector<unsigned char> buf (cnt,
version);
435 error (_(
"No ADI information"));
436 else if (set_cnt < cnt)
452 error (_(
"ADI command requires a live process/thread"));
455 error (_(
"No ADI information"));
458 const char *p = args;
466 if (p != 0 && *p != 0)
469 error (_(
"Usage: adi examine|x[/COUNT] [ADDR]"));
483 static const char *adi_usage
484 = N_(
"Usage: adi assign|a[/COUNT] ADDR = VERSION");
488 error (_(
"ADI command requires a live process/thread"));
491 error (_(
"No ADI information"));
493 const char *exp = args;
497 char *q = (
char *) strchr (exp,
'=');
501 error (
"%s", _(adi_usage));
504 const char *p = args;
505 if (exp && *exp ==
'/')
512 if (p != 0 && *p != 0)
515 error (
"%s", _(adi_usage));
523 error (_(
"Invalid ADI version tag %d"),
version);
534 _(
"ADI version related commands."),
560 case TYPE_CODE_RANGE:
563 gdb_assert (len == 1 || len == 2 || len == 4 || len == 8);
568 case TYPE_CODE_RVALUE_REF:
571 gdb_assert (len == 8);
591 gdb_assert (len == 4 || len == 8 || len == 16);
608 case TYPE_CODE_COMPLEX:
611 gdb_assert (len == 8 || len == 16 || len == 32);
632 case TYPE_CODE_STRUCT:
633 case TYPE_CODE_UNION:
634 case TYPE_CODE_ARRAY:
753#define SPARC64_FPU_REGISTERS \
754 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
755 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
756 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
757 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \
758 "f32", "f34", "f36", "f38", "f40", "f42", "f44", "f46", \
759 "f48", "f50", "f52", "f54", "f56", "f58", "f60", "f62"
760#define SPARC64_CP0_REGISTERS \
783#define SPARC64_NUM_REGS ARRAY_SIZE (sparc64_register_names)
790 "cwp",
"pstate",
"asi",
"ccr",
792 "d0",
"d2",
"d4",
"d6",
"d8",
"d10",
"d12",
"d14",
793 "d16",
"d18",
"d20",
"d22",
"d24",
"d26",
"d28",
"d30",
794 "d32",
"d34",
"d36",
"d38",
"d40",
"d42",
"d44",
"d46",
795 "d48",
"d50",
"d52",
"d54",
"d56",
"d58",
"d60",
"d62",
797 "q0",
"q4",
"q8",
"q12",
"q16",
"q20",
"q24",
"q28",
798 "q32",
"q36",
"q40",
"q44",
"q48",
"q52",
"q56",
"q60",
802#define SPARC64_NUM_PSEUDO_REGS ARRAY_SIZE (sparc64_pseudo_register_names)
850 internal_error (_(
"sparc64_pseudo_register_type: bad register number %d"),
891 internal_error (_(
"invalid regnum"));
894static enum register_status
897 int regnum, gdb_byte *buf)
900 enum register_status
status;
955 state = (state >> 0) & ((1 << 5) - 1);
958 state = (state >> 8) & ((1 << 12) - 1);
961 state = (state >> 24) & ((1 << 8) - 1);
964 state = (state >> 32) & ((1 << 8) - 1);
976 int regnum,
const gdb_byte *buf)
1012 ULONGEST state,
bits;
1019 state |= ((
bits & ((1 << 5) - 1)) << 0);
1022 state |= ((
bits & ((1 << 12) - 1)) << 8);
1025 state |= ((
bits & ((1 << 8) - 1)) << 24);
1028 state |= ((
bits & ((1 << 8) - 1)) << 32);
1043 CORE_ADDR func_start, func_end;
1052 if (sal.
end < func_end
1053 && start_pc <= sal.
end)
1077 if (cache->
base == 0)
1083static struct value *
1169 if (
type->
code () == TYPE_CODE_ARRAY)
1203 const gdb_byte *valbuf,
int element,
int bitpos)
1208 gdb_assert (element < 16);
1210 if (
type->
code () == TYPE_CODE_ARRAY)
1215 valbuf += bitpos / 8;
1218 memset (buf, 0, 8 - len);
1219 memcpy (buf + 8 - len, valbuf, len);
1223 for (
int n = 0; n < (len + 3) / 4; n++)
1233 gdb_assert (bitpos == 0);
1234 gdb_assert ((element % 2) == 0);
1241 gdb_assert (bitpos == 0 || bitpos == 64);
1244 + element + bitpos / 64;
1249 gdb_assert (len == 4);
1250 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 128);
1295 gdb_byte *valbuf,
int bitpos)
1299 if (
type->
code () == TYPE_CODE_ARRAY)
1304 valbuf += bitpos / 8;
1309 memcpy (valbuf, buf + 4 - len, len);
1312 for (
int i = 0; i < (len + 3) / 4; i++)
1322 gdb_assert (bitpos == 0 || bitpos == 128);
1330 gdb_assert (bitpos % 64 == 0 && bitpos >= 0 && bitpos < 256);
1337 gdb_assert (len == 4);
1338 gdb_assert (bitpos % 32 == 0 && bitpos >= 0 && bitpos < 256);
1363 struct value **args, CORE_ADDR sp,
1365 CORE_ADDR struct_addr)
1369 int num_elements = 0;
1382 for (i = 0; i < nargs; i++)
1384 struct type *
type = args[i]->type ();
1395 num_elements += ((len + 7) / 8);
1456 sp -= num_elements * 8;
1481 for (i = 0; i < nargs; i++)
1483 const gdb_byte *valbuf = args[i]->contents ().data ();
1484 struct type *
type = args[i]->type ();
1493 gdb_assert (len <= 16);
1494 memset (buf, 0,
sizeof (buf));
1495 memcpy (buf, valbuf, len);
1504 if (len > 8 && element < 5)
1554 memcpy (buf + 4, valbuf, 4);
1565 gdb_assert (len == 8);
1582 gdb_assert (element < 6);
1588 gdb_assert (element < 5);
1598 element += ((len + 7) / 8);
1601 gdb_assert (element == num_elements);
1612 return address & ~0xf;
1618 int nargs,
struct value **args, CORE_ADDR sp,
1620 CORE_ADDR struct_addr)
1633 gdb_assert ((sp +
BIAS) % 16 == 0);
1656 gdb_assert (len <= 32);
1658 for (i = 0; i < ((len + 7) / 8); i++)
1660 if (
type->
code () != TYPE_CODE_UNION)
1662 memcpy (valbuf, buf, len);
1667 for (i = 0; i < len / 4; i++)
1669 memcpy (valbuf, buf, len);
1671 else if (
type->
code () == TYPE_CODE_ARRAY)
1674 gdb_assert (len <= 32);
1676 for (i = 0; i < ((len + 7) / 8); i++)
1678 memcpy (valbuf, buf, len);
1688 memcpy (valbuf, buf + 8 - len, len);
1697 const gdb_byte *valbuf)
1706 gdb_assert (len <= 32);
1711 memset (buf, 0,
sizeof (buf));
1712 memcpy (buf, valbuf, len);
1713 for (i = 0; i < ((len + 7) / 8); i++)
1715 if (
type->
code () != TYPE_CODE_UNION)
1721 memcpy (buf, valbuf, len);
1722 for (i = 0; i < len / 4; i++)
1725 else if (
type->
code () == TYPE_CODE_ARRAY)
1728 gdb_assert (len <= 32);
1730 memset (buf, 0,
sizeof (buf));
1731 memcpy (buf, valbuf, len);
1732 for (i = 0; i < ((len + 7) / 8); i++)
1742 memcpy (buf + 8 - len, valbuf, len);
1750 gdb_byte *readbuf,
const gdb_byte *writebuf)
1859#define TSTATE_CWP 0x000000000000001fULL
1860#define TSTATE_ICC 0x0000000f00000000ULL
1861#define TSTATE_XCC 0x000000f000000000ULL
1863#define PSR_S 0x00000080
1865#define PSR_ICC 0x00f00000
1867#define PSR_VERS 0x0f000000
1869#define PSR_IMPL 0xf0000000
1871#define PSR_V8PLUS 0xff000000
1872#define PSR_XCC 0x000f0000
1877 int regnum,
const void *gregs)
1882 const gdb_byte *regs = (
const gdb_byte *) gregs;
1883 gdb_byte zero[8] = { 0 };
1890 int offset = gregmap->r_tstate_offset;
1891 ULONGEST tstate, psr;
1919 regs + gregmap->r_tstate_offset);
1934 memcpy (buf + 8 - gregmap->
r_y_size,
1940 && gregmap->r_fprs_offset != -1)
1942 regs + gregmap->r_fprs_offset);
1999 gdb_byte *regs = (gdb_byte *) gregs;
2006 int offset = gregmap->r_tstate_offset;
2007 ULONGEST tstate, psr;
2013 tstate |= (psr &
PSR_ICC) << 12;
2015 tstate |= (psr &
PSR_XCC) << 20;
2017 memcpy (regs + offset, buf, 8);
2038 regs + gregmap->r_tstate_offset);
2058 && gregmap->r_fprs_offset != -1)
2060 regs + gregmap->r_fprs_offset);
2104 int regnum,
const void *fpregs)
2107 const gdb_byte *regs = (
const gdb_byte *) fpregs;
2110 for (i = 0; i < 32; i++)
2125 for (i = 0; i < 16; i++)
2130 regs + fpregmap->
r_f0_offset + (32 * 4) + (i * 8));
2142 int regnum,
void *fpregs)
2145 gdb_byte *regs = (gdb_byte *) fpregs;
2148 for (i = 0; i < 32; i++)
2163 for (i = 0; i < 16; i++)
2168 + (32 * 4) + (i * 8)));
#define bits(obj, st, fn)
struct gdbarch * target_gdbarch(void)
int default_stabs_argument_has_addr(struct gdbarch *gdbarch, struct type *type)
enum return_value_convention default_gdbarch_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, struct value **read_value, const gdb_byte *writebuf)
int target_auxv_search(const gdb::byte_vector &auxv, target_ops *ops, gdbarch *gdbarch, CORE_ADDR match, CORE_ADDR *valp)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
enum register_status raw_read(int regnum, gdb_byte *buf)
enum register_status cooked_read(int regnum, gdb_byte *buf)
void raw_collect(int regnum, void *buf) const override
void raw_supply(int regnum, const void *buf) override
void cooked_write(int regnum, const gdb_byte *buf)
void raw_write(int regnum, const gdb_byte *buf)
void error_no_arg(const char *why)
struct cmd_list_element * cmdlist
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
struct cmd_list_element * add_basic_prefix_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **subcommands, int allow_unknown, struct cmd_list_element **list)
int get_number(const char **pp)
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_REGISTER_CONVENTION
@ RETURN_VALUE_STRUCT_CONVENTION
void dwarf2_frame_set_init_reg(struct gdbarch *gdbarch, void(*init_reg)(struct gdbarch *, int, struct dwarf2_frame_state_reg *, frame_info_ptr))
@ DWARF2_FRAME_REG_RA_OFFSET
@ DWARF2_FRAME_REG_SAME_VALUE
LONGEST parse_and_eval_long(const char *exp)
CORE_ADDR parse_and_eval_address(const char *exp)
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
int default_frame_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
struct value * frame_unwind_got_memory(frame_info_ptr frame, int regnum, CORE_ADDR addr)
struct value * frame_unwind_got_register(frame_info_ptr frame, int regnum, int new_regnum)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
struct value * frame_unwind_got_constant(frame_info_ptr frame, int regnum, ULONGEST val)
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
ULONGEST get_frame_register_unsigned(frame_info_ptr frame, int regnum)
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
struct gdbarch * get_frame_arch(frame_info_ptr this_frame)
ULONGEST get_frame_memory_unsigned(frame_info_ptr this_frame, CORE_ADDR addr, int len)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void set_gdbarch_return_value_as_value(struct gdbarch *gdbarch, gdbarch_return_value_as_value_ftype *return_value_as_value)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
void set_gdbarch_addr_bits_remove(struct gdbarch *gdbarch, gdbarch_addr_bits_remove_ftype *addr_bits_remove)
void set_gdbarch_wchar_bit(struct gdbarch *gdbarch, int wchar_bit)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_push_dummy_code(struct gdbarch *gdbarch, gdbarch_push_dummy_code_ftype *push_dummy_code)
void set_gdbarch_stabs_argument_has_addr(struct gdbarch *gdbarch, gdbarch_stabs_argument_has_addr_ftype *stabs_argument_has_addr)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_wchar_signed(struct gdbarch *gdbarch, int wchar_signed)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_call_dummy_location(struct gdbarch *gdbarch, enum call_dummy_location_type call_dummy_location)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
const struct target_desc * gdbarch_target_desc(struct gdbarch *gdbarch)
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p)
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype *pseudo_register_write)
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read)
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
function_call_return_method
struct type * lookup_pointer_type(struct type *type)
void append_flags_type_flag(struct type *type, int bitpos, const char *name)
struct type * arch_flags_type(struct gdbarch *gdbarch, const char *name, int bit)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
struct type * check_typedef(struct type *type)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
static CORE_ADDR next_address
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void sparc_supply_rwindow(struct regcache *regcache, CORE_ADDR sp, int regnum)
struct sparc_frame_cache * sparc_frame_cache(frame_info_ptr this_frame, void **this_cache)
CORE_ADDR sparc_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct sparc_frame_cache *cache)
int sparc_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
ULONGEST sparc_fetch_wcookie(struct gdbarch *gdbarch)
#define SPARC_CORE_REGISTERS
static int sparc64_integral_or_pointer_p(const struct type *type)
static const struct frame_unwind sparc64_frame_unwind
static CORE_ADDR sparc64_store_arguments(struct regcache *regcache, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
static void sparc64_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static int adi_convert_byte_count(CORE_ADDR naddr, int nbytes, CORE_ADDR locl)
static CORE_ADDR adi_align_address(CORE_ADDR naddr)
static void adi_examine_command(const char *args, int from_tty)
static const char *const sparc64_pseudo_register_names[]
void sparc64_supply_gregset(const struct sparc_gregmap *gregmap, struct regcache *regcache, int regnum, const void *gregs)
void _initialize_sparc64_adi_tdep()
static void adi_assign_command(const char *args, int from_tty)
void sparc64_supply_fpregset(const struct sparc_fpregmap *fpregmap, struct regcache *regcache, int regnum, const void *fpregs)
static struct type * sparc64_ccr_type(struct gdbarch *gdbarch)
static void do_examine(CORE_ADDR start, int bcnt)
static struct sparc_frame_cache * sparc64_frame_cache(frame_info_ptr this_frame, void **this_cache)
void sparc64_collect_fpregset(const struct sparc_fpregmap *fpregmap, const struct regcache *regcache, int regnum, void *fpregs)
static void read_maps_entry(const char *line, ULONGEST *addr, ULONGEST *endaddr)
static const char *const sparc64_cp0_register_names[]
static struct type * sparc64_fprs_type(struct gdbarch *gdbarch)
#define MAX_PROC_NAME_SIZE
static void sparc64_store_floating_fields(struct regcache *regcache, struct type *type, const gdb_byte *valbuf, int element, int bitpos)
void sparc64_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
static const char * sparc64_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
static void sparc64_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
const struct sparc_fpregmap sparc64_bsd_fpregmap
static int sparc64_complex_floating_p(const struct type *type)
static CORE_ADDR sparc64_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
static CORE_ADDR adi_normalize_address(CORE_ADDR addr)
static CORE_ADDR sparc64_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc)
static int adi_read_versions(CORE_ADDR vaddr, size_t size, gdb_byte *tags)
static void do_assign(CORE_ADDR start, size_t bcnt, int version)
static const char *const sparc64_fpu_register_names[]
static const char *const sparc64_register_names[]
static struct type * sparc64_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
static int sparc64_structure_or_union_p(const struct type *type)
static const char * sparc64_register_name(struct gdbarch *gdbarch, int regnum)
static void sparc64_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static enum register_status sparc64_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf)
static void sparc64_extract_floating_fields(struct regcache *regcache, struct type *type, gdb_byte *valbuf, int bitpos)
static enum return_value_convention sparc64_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static int adi_write_versions(CORE_ADDR vaddr, size_t size, unsigned char *tags)
static struct type * sparc64_fsr_type(struct gdbarch *gdbarch)
static CORE_ADDR sparc64_frame_align(struct gdbarch *gdbarch, CORE_ADDR address)
static CORE_ADDR sparc64_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
static struct value * sparc64_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static const struct frame_base sparc64_frame_base
#define SPARC64_CP0_REGISTERS
static int sparc64_floating_p(const struct type *type)
static void sparc64_dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, frame_info_ptr this_frame)
#define SPARC64_FPU_REGISTERS
static bool adi_is_addr_mapped(CORE_ADDR vaddr, size_t cnt)
static struct cmd_list_element * sparc64adilist
#define SPARC64_NUM_PSEUDO_REGS
static struct type * sparc64_pstate_type(struct gdbarch *gdbarch)
static CORE_ADDR sparc64_frame_base_address(frame_info_ptr this_frame, void **this_cache)
static std::forward_list< sparc64_adi_info > adi_proc_list
static int sparc64_16_byte_align_p(struct type *type)
static sparc64_adi_info * get_adi_info_proc(pid_t pid)
static adi_stat_t get_adi_info(pid_t pid)
void sparc64_forget_process(pid_t pid)
static void sparc64_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
static bool adi_available(void)
static void adi_print_versions(CORE_ADDR vaddr, size_t cnt, gdb_byte *tags)
static struct type * sparc64_register_type(struct gdbarch *gdbarch, int regnum)
static int adi_tag_fd(void)
void sparc64_collect_gregset(const struct sparc_gregmap *gregmap, const struct regcache *regcache, int regnum, void *gregs)
struct type * builtin_double
struct type * builtin_func_ptr
struct type * builtin_data_ptr
struct type * builtin_long_double
struct type * builtin_int64
struct type * builtin_float
union dwarf2_frame_state_reg::@46 loc
enum dwarf2_frame_reg_rule how
LONGEST loc_bitpos() const
struct type * type() const
sparc64_adi_info(pid_t pid_)
unsigned char copied_regs_mask
unsigned short int saved_regs_mask
struct type * sparc64_fprs_type
const char *const * fpu_register_names
const char *const * cp0_register_names
struct type * sparc64_pstate_type
struct type * sparc64_ccr_type
struct type * sparc64_fsr_type
struct type * target_type() const
struct field & field(int idx) const
unsigned int num_fields() const
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
void set_tdesc_pseudo_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *pseudo_name)
int tdesc_has_registers(const struct target_desc *target_desc)
void set_tdesc_pseudo_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *pseudo_type)
struct type * tdesc_register_type(struct gdbarch *gdbarch, int regno)
const char * tdesc_register_name(struct gdbarch *gdbarch, int regno)
int target_fileio_pwrite(int fd, const gdb_byte *write_buf, int len, ULONGEST offset, fileio_error *target_errno)
gdb::unique_xmalloc_ptr< char > target_fileio_read_stralloc(struct inferior *inf, const char *filename)
int target_fileio_open(struct inferior *inf, const char *filename, int flags, int mode, bool warn_if_slow, fileio_error *target_errno)
int target_fileio_close(int fd, fileio_error *target_errno)
int target_fileio_pread(int fd, gdb_byte *read_buf, int len, ULONGEST offset, fileio_error *target_errno)
bool target_has_execution(inferior *inf)
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
void gdb_printf(struct ui_file *stream, const char *format,...)
struct value * value_cast(struct type *type, struct value *arg2)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)