71#define X_OP(i) (((i) >> 30) & 0x3)
72#define X_RD(i) (((i) >> 25) & 0x1f)
73#define X_A(i) (((i) >> 29) & 1)
74#define X_COND(i) (((i) >> 25) & 0xf)
75#define X_OP2(i) (((i) >> 22) & 0x7)
76#define X_IMM22(i) ((i) & 0x3fffff)
77#define X_OP3(i) (((i) >> 19) & 0x3f)
78#define X_RS1(i) (((i) >> 14) & 0x1f)
79#define X_RS2(i) ((i) & 0x1f)
80#define X_I(i) (((i) >> 13) & 1)
82#define X_DISP22(i) ((X_IMM22 (i) ^ 0x200000) - 0x200000)
83#define X_DISP19(i) ((((i) & 0x7ffff) ^ 0x40000) - 0x40000)
84#define X_DISP10(i) ((((((i) >> 11) && 0x300) | (((i) >> 5) & 0xff)) ^ 0x200) - 0x200)
85#define X_SIMM13(i) ((((i) & 0x1fff) ^ 0x1000) - 0x1000)
88#define X_RETTURN(i) ((X_OP (i) == 0x2) && (X_OP3 (i) == 0x39))
105 for (i = 0; i <
sizeof (buf); i++)
106 insn = (insn << 8) | buf[i];
119 return ((insn & 0xc1c00000) == 0);
143 const unsigned op2 =
X_OP2 (insn);
145 if ((
X_OP (insn) == 0)
146 && ((op2 == 1) || (op2 == 2) || (op2 == 5) || (op2 == 6)
147 || ((op2 == 3) && ((insn & 0x10000000) == 0))))
197 gdb_assert (len == 4 || len == 8);
219 case TYPE_CODE_RANGE:
223 return (len == 1 || len == 2 || len == 4 || len == 8);
226 case TYPE_CODE_RVALUE_REF:
228 return (len == 4 || len == 8);
246 return (len == 4 || len == 8 || len == 16);
262 case TYPE_CODE_COMPLEX:
265 return (len == 8 || len == 16 || len == 32);
285 case TYPE_CODE_STRUCT:
286 case TYPE_CODE_UNION:
287 case TYPE_CODE_ARRAY:
354#define SPARC32_FPU_REGISTERS \
355 "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \
356 "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \
357 "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \
358 "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31"
359#define SPARC32_CP0_REGISTERS \
360 "y", "psr", "wim", "tbr", "pc", "npc", "fsr", "csr"
380#define SPARC32_NUM_REGS ARRAY_SIZE (sparc32_register_names)
387 "d0",
"d2",
"d4",
"d6",
"d8",
"d10",
"d12",
"d14",
388 "d16",
"d18",
"d20",
"d22",
"d24",
"d26",
"d28",
"d30"
392#define SPARC32_NUM_PSEUDO_REGS ARRAY_SIZE (sparc32_pseudo_register_names)
487 internal_error (_(
"sparc32_pseudo_register_type: bad register number %d"),
521static enum register_status
524 int regnum, gdb_byte *buf)
526 enum register_status
status;
541 int regnum,
const gdb_byte *buf)
579 return address & ~0x7;
585 struct value **args,
int nargs,
586 struct type *value_type,
587 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
601 value_type->
length () & 0x1fff);
611 struct value **args, CORE_ADDR sp,
613 CORE_ADDR struct_addr)
618 int num_elements = 0;
622 for (i = 0; i < nargs; i++)
624 struct type *
type = args[i]->type ();
643 gdb_assert (len == 4 || len == 8);
644 num_elements += (len / 4);
649 num_elements += ((len + 3) / 4);
654 sp -= std::max (6, num_elements) * 4;
665 for (i = 0; i < nargs; i++)
667 const bfd_byte *valbuf = args[i]->contents ().data ();
668 struct type *
type = args[i]->type ();
674 memset (buf, 0, 4 - len);
675 memcpy (buf + 4 - len, valbuf, len);
680 gdb_assert (len == 4 || len == 8);
687 if (len > 4 && element < 5)
696 gdb_assert (element == num_elements);
712 int nargs,
struct value **args, CORE_ADDR sp,
714 CORE_ADDR struct_addr)
717 ? (bp_addr - 12) : (bp_addr - 8));
730 gdb_assert (sp % 8 == 0);
752sparc_alloc_frame_cache (
void)
780 CORE_ADDR
pc = start_pc;
782 int probing_loop = 0;
808 if (!(
X_OP (insn) == 0 &&
X_OP2 (insn) == 0x4 &&
X_RD (insn) == 1))
814 if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 0x4 &&
X_RD (insn) == 4)
822 if (!(
X_OP (insn) == 2 &&
X_OP3 (insn) == 0x4 && !
X_I(insn)
830 if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 0x4 &&
X_RD (insn) == 4)
843 &&
X_RS1 (insn) == 1 &&
X_RD (insn) == 0)
858 else if (
X_OP (insn) == 3 &&
X_OP3(insn) == 0x4 && !
X_I(insn)
859 &&
X_RS1 (insn) == 1 &&
X_RD (insn) == 0)
867 &&
X_RS1 (insn) == 1 &&
X_RD (insn) == 1))
873 if (!(
X_OP (insn) == 3 &&
X_OP3(insn) == 0x4 && !
X_I(insn)
874 &&
X_RD (insn) == 0 &&
X_RS1 (insn) == 1))
879 if (!(
X_OP (insn) == 3 &&
X_OP3(insn) == 0x4 &&
X_I(insn)
880 &&
X_RS1 (insn) == 1 &&
X_RD (insn) == 0))
903 if (!(
X_OP (insn) == 2 &&
X_OP3 (insn) == 0x4 && !
X_I(insn)
910 if (!(
X_OP (insn) == 2 &&
X_OP3 (insn) == 0x14 && !
X_I(insn)
917 if (!(
X_OP (insn) == 0 &&
X_COND (insn) == 0x1))
924 &&
X_RS1 (insn) == 1 &&
X_RD (insn) == 1))
930 if (!(
X_OP (insn) == 0 &&
X_COND (insn) == 0x8))
936 if (!(
X_OP (insn) == 3 &&
X_OP3(insn) == 0x4
946 if (!(
X_OP (insn) == 3 &&
X_OP3(insn) == 0x4 &&
X_I(insn)
947 &&
X_RS1 (insn) == 4 &&
X_RD (insn) == 0))
993 if (current_pc <=
pc)
1012 while (
X_OP (insn) == 3
1013 && (
X_OP3 (insn) == 0x4
1014 ||
X_OP3 (insn) == 0x7
1015 ||
X_OP3 (insn) == 0xe)
1029 if (
X_OP3 (insn) == 0x7)
1039 if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 0x04)
1048 if (
X_OP (insn) == 2 &&
X_I (insn)
1049 && (
X_RD (insn) == 1 ||
X_RD (insn) == dest))
1057 if (
X_OP (insn) == 2 &&
X_OP3 (insn) == 0x3c)
1065 if (
X_OP (insn) == 2
1066 && (
X_OP3 (insn) == 0 ||
X_OP3 (insn) == 0x4)
1073 if (
X_OP3 (insn) == 0)
1081 if (
X_OP (insn) == 2
1082 && (
X_OP3 (insn) == 0 ||
X_OP3 (insn) == 0x4)
1097 if (
X_OP (insn) == 2
1098 &&
X_OP3 (insn) == 0x2
1120 CORE_ADDR func_addr;
1128 CORE_ADDR post_prologue_pc
1131 if (post_prologue_pc != 0)
1132 return std::max (start_pc, post_prologue_pc);
1152 if (
X_OP (insn) == 3 && (
X_OP3 (insn) & 0x3c) == 0x04
1192 cache = sparc_alloc_frame_cache ();
1193 *this_cache = cache;
1218 if (cache->
base & 1)
1230 if (
code == TYPE_CODE_FUNC ||
code == TYPE_CODE_METHOD)
1285 if (cache->
base == 0)
1291static struct value *
1293 void **this_cache,
int regnum)
1403 ||
type->
code () == TYPE_CODE_ARRAY)
1421 memcpy (valbuf, buf, len);
1432 gdb_assert (len == 8);
1433 memcpy (valbuf, buf, 8);
1439 memcpy (valbuf, buf + 4 - len, len);
1449 const gdb_byte *valbuf)
1459 memcpy (buf, valbuf, len);
1483 gdb_assert (len == 8);
1484 memcpy (buf, valbuf, 8);
1490 memcpy (buf + 4 - len, valbuf, len);
1499 struct value **read_value,
const gdb_byte *writebuf)
1515 if (read_value !=
nullptr)
1531 if (read_value !=
nullptr)
1534 gdb_byte *readbuf = (*read_value)->contents_raw ().data ();
1600 if (op != DW_CFA_GNU_window_save)
1606 fs->
regs.alloc_regs (32);
1607 for (reg = 8; reg < 16; reg++)
1610 fs->
regs.reg[reg].loc.reg = reg + 16;
1612 for (reg = 16; reg < 32; reg++)
1615 fs->
regs.reg[reg].loc.offset = (reg - 16) *
size;
1628 CORE_ADDR pc, CORE_ADDR *npc)
1631 int conditional_p =
X_COND (insn) & 0x7;
1632 int branch_p = 0, fused_p = 0;
1635 if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 3)
1637 if ((insn & 0x10000000) == 0)
1651 else if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 6)
1657 else if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 5)
1664 else if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 2)
1670 else if (
X_OP (insn) == 0 &&
X_OP2 (insn) == 1)
1676 else if (
X_OP (insn) == 2 &&
X_OP3 (insn) == 0x3a)
1696 gdb_assert (offset != 0);
1699 else if (conditional_p)
1703 return (
X_A (insn) ? *npc + 4 : 0);
1711 if (
X_COND (insn) == 0x0)
1712 pc = *npc, offset = 4;
1729static std::vector<CORE_ADDR>
1734 CORE_ADDR npc, nnpc;
1736 CORE_ADDR pc, orig_npc;
1737 std::vector<CORE_ADDR> next_pcs;
1745 next_pcs.push_back (npc);
1748 next_pcs.push_back (nnpc);
1753 gdb_assert (npc != 0 || nnpc != 0 || orig_npc == 0);
1754 gdb_assert (nnpc != npc || orig_npc == 0);
1790 const char *feature_name,
1791 const char *
const register_names[],
1792 unsigned int registers_num,
1793 unsigned int reg_start)
1796 const struct tdesc_feature *feature;
1799 if (feature == NULL)
1802 for (
unsigned int i = 0; i < registers_num; i++)
1813 const struct target_desc *tdesc = info.target_desc;
1870 sparc_breakpoint::kind_from_pc);
1872 sparc_breakpoint::bp_from_kind);
1903 "org.gnu.gdb.sparc.cpu",
1908 "org.gnu.gdb.sparc.fpu",
1913 "org.gnu.gdb.sparc.cp0",
2016 CORE_ADDR sp,
int regnum)
2091 int regnum,
const void *gregs)
2093 const gdb_byte *regs = (
const gdb_byte *) gregs;
2094 gdb_byte zero[4] = { 0 };
2154 gdb_byte *regs = (gdb_byte *) gregs;
2203 int regnum,
const void *fpregs)
2205 const gdb_byte *regs = (
const gdb_byte *) fpregs;
2208 for (i = 0; i < 32; i++)
2222 int regnum,
void *fpregs)
2224 gdb_byte *regs = (gdb_byte *) fpregs;
2227 for (i = 0; i < 32; i++)
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep, gdbarch_supports_arch_info_ftype *supports_arch_info)
static std::vector< const char * > arches
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
#define BP_MANIPULATION(BREAK_INSN)
struct symbol * find_pc_function(CORE_ADDR pc)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
target_ops * top_target()
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 write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
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_ABI_PRESERVES_ADDRESS
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_SAVED_REG
@ DWARF2_FRAME_REG_RA_OFFSET
@ DWARF2_FRAME_REG_SAVED_OFFSET
@ DWARF2_FRAME_REG_SAME_VALUE
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)
CORE_ADDR get_frame_pc(frame_info_ptr frame)
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)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
frame_info_ptr get_current_frame(void)
CORE_ADDR get_frame_address_in_block(frame_info_ptr this_frame)
#define FRAME_OBSTACK_ZALLOC(TYPE)
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_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype *breakpoint_kind_from_pc)
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype *software_single_step)
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype *frame_align)
void set_gdbarch_write_pc(struct gdbarch *gdbarch, gdbarch_write_pc_ftype *write_pc)
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype *skip_prologue)
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_wchar_signed(struct gdbarch *gdbarch, int wchar_signed)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_execute_dwarf_cfa_vendor_op(struct gdbarch *gdbarch, gdbarch_execute_dwarf_cfa_vendor_op_ftype *execute_dwarf_cfa_vendor_op)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype *inner_than)
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
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_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_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)
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype *dummy_id)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype *iterate_over_regset_sections)
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
std::unique_ptr< gdbarch_tdep_base > gdbarch_tdep_up
void iterate_over_regset_sections_cb(const char *sect_name, int supply_size, int collect_size, const struct regset *regset, const char *human_name, void *cb_data)
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)
const struct floatformat * floatformats_ieee_quad[BFD_ENDIAN_UNKNOWN]
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 status
struct inferior * current_inferior(void)
static int in_plt_section(CORE_ADDR pc)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
int register_size(struct gdbarch *gdbarch, int regnum)
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
void register_sparc_ravenscar_ops(struct gdbarch *gdbarch)
static struct type * sparc_fsr_type(struct gdbarch *gdbarch)
#define SPARC32_FPU_REGISTERS
constexpr gdb_byte sparc_break_insn[]
void sparc_supply_rwindow(struct regcache *regcache, CORE_ADDR sp, int regnum)
static void sparc32_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regnum, const gdb_byte *buf)
static struct type * sparc32_pseudo_register_type(struct gdbarch *gdbarch, int regnum)
static void sparc_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
static CORE_ADDR sparc_skip_stack_check(const CORE_ADDR start_pc)
struct sparc_frame_cache * sparc_frame_cache(frame_info_ptr this_frame, void **this_cache)
static struct frame_id sparc_dummy_id(struct gdbarch *gdbarch, frame_info_ptr this_frame)
#define SPARC32_NUM_PSEUDO_REGS
void sparc_record_save_insn(struct sparc_frame_cache *cache)
static int sparc_integral_or_pointer_p(const struct type *type)
static CORE_ADDR sparc32_frame_align(struct gdbarch *gdbarch, CORE_ADDR address)
static const char * sparc32_register_name(struct gdbarch *gdbarch, int regnum)
static CORE_ADDR sparc_step_trap(frame_info_ptr frame, unsigned long insn)
static bool sparc_arg_by_memory_p(const struct type *type)
static const char *const sparc32_register_names[]
static const char *const sparc32_pseudo_register_names[]
void _initialize_sparc_tdep()
static int sparc_structure_or_union_p(const struct type *type)
static CORE_ADDR sparc32_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 int sparc_is_unimp_insn(CORE_ADDR pc)
static struct gdbarch * sparc32_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static int sparc32_struct_return_from_sym(struct symbol *sym)
CORE_ADDR sparc_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR current_pc, struct sparc_frame_cache *cache)
static void sparc_write_pc(struct regcache *regcache, CORE_ADDR pc)
int sparc_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
static const char *const sparc32_cp0_register_names[]
void sparc_collect_rwindow(const struct regcache *regcache, CORE_ADDR sp, int regnum)
static void sparc32_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
ULONGEST sparc_fetch_wcookie(struct gdbarch *gdbarch)
#define SPARC32_CP0_REGISTERS
static bool sparc_execute_dwarf_cfa_vendor_op(struct gdbarch *gdbarch, gdb_byte op, struct dwarf2_frame_state *fs)
static struct value * sparc32_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static const struct frame_base sparc32_frame_base
int sparc_is_annulled_branch_insn(CORE_ADDR pc)
static const char * sparc32_pseudo_register_name(struct gdbarch *gdbarch, int regnum)
void sparc32_supply_gregset(const struct sparc_gregmap *gregmap, struct regcache *regcache, int regnum, const void *gregs)
static int sparc32_stabs_argument_has_addr(struct gdbarch *gdbarch, struct type *type)
static CORE_ADDR sparc32_push_dummy_code(struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funcaddr, struct value **args, int nargs, struct type *value_type, CORE_ADDR *real_pc, CORE_ADDR *bp_addr, struct regcache *regcache)
static int sparc32_dwarf2_struct_return_p(frame_info_ptr this_frame)
static int sparc_complex_floating_p(const struct type *type)
unsigned long sparc_fetch_instruction(CORE_ADDR pc)
static CORE_ADDR sparc32_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc)
const struct sparc_fpregmap sparc32_sunos4_fpregmap
static const struct frame_unwind sparc32_frame_unwind
static const char *const sparc_core_register_names[]
const struct sparc_gregmap sparc32_sunos4_gregmap
static const char *const sparc32_fpu_register_names[]
static enum return_value_convention sparc32_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, struct value **read_value, const gdb_byte *writebuf)
static bool sparc_structure_return_p(const struct type *type)
static struct type * sparc_psr_type(struct gdbarch *gdbarch)
static struct type * sparc32_register_type(struct gdbarch *gdbarch, int regnum)
static enum register_status sparc32_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int regnum, gdb_byte *buf)
static CORE_ADDR sparc32_frame_base_address(frame_info_ptr this_frame, void **this_cache)
static CORE_ADDR sparc_analyze_control_transfer(struct regcache *regcache, CORE_ADDR pc, CORE_ADDR *npc)
const struct sparc_fpregmap sparc32_bsd_fpregmap
void sparc32_supply_fpregset(const struct sparc_fpregmap *fpregmap, struct regcache *regcache, int regnum, const void *fpregs)
static int sparc_floating_p(const struct type *type)
static int validate_tdesc_registers(const struct target_desc *tdesc, struct tdesc_arch_data *tdesc_data, const char *feature_name, const char *const register_names[], unsigned int registers_num, unsigned int reg_start)
struct sparc_frame_cache * sparc32_frame_cache(frame_info_ptr this_frame, void **this_cache)
void sparc32_collect_fpregset(const struct sparc_fpregmap *fpregmap, const struct regcache *regcache, int regnum, void *fpregs)
static std::vector< CORE_ADDR > sparc_software_single_step(struct regcache *regcache)
static void sparc32_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static void sparc32_dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, frame_info_ptr this_frame)
void sparc32_collect_gregset(const struct sparc_gregmap *gregmap, const struct regcache *regcache, int regnum, void *gregs)
static CORE_ADDR sparc32_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 sparc32_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
#define SPARC_CORE_REGISTERS
struct type * builtin_double
struct type * builtin_func_ptr
struct type * builtin_data_ptr
struct type * builtin_int32
struct type * builtin_float
union dwarf2_frame_state_reg::@46 loc
enum dwarf2_frame_reg_rule how
unsigned char copied_regs_mask
unsigned short int saved_regs_mask
struct type * sparc_fsr_type
const char *const * fpu_register_names
CORE_ADDR(* step_trap)(frame_info_ptr frame, unsigned long insn)
const struct regset * fpregset
struct type * sparc_psr_type
const char *const * cp0_register_names
const struct regset * gregset
struct type * type() const
struct type * target_type() const
static struct value * allocate(struct type *type)
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
tdesc_arch_data_up tdesc_data_alloc(void)
const struct tdesc_feature * tdesc_find_feature(const struct target_desc *target_desc, const char *name)
int tdesc_numbered_register(const struct tdesc_feature *feature, struct tdesc_arch_data *data, int regno, const char *name)
static const registry< gdbarch >::key< tdesc_arch_data > tdesc_data
void tdesc_use_registers(struct gdbarch *gdbarch, const struct target_desc *target_desc, tdesc_arch_data_up &&early_data, tdesc_unknown_register_ftype unk_reg_cb)
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)
std::unique_ptr< tdesc_arch_data, tdesc_arch_data_deleter > tdesc_arch_data_up
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
struct value * value_at_non_lval(struct type *type, CORE_ADDR addr)
struct value * value_from_pointer(struct type *type, CORE_ADDR addr)
int using_struct_return(struct gdbarch *gdbarch, struct value *function, struct type *value_type)