52#include "sim/sim-sh.h"
112 static const char *register_names[] = {
113 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
114 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
115 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr"
118 if (reg_nr >= ARRAY_SIZE (register_names))
120 return register_names[reg_nr];
126 static const char *register_names[] = {
127 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
128 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
129 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
131 "",
"",
"",
"",
"",
"",
"",
"",
132 "",
"",
"",
"",
"",
"",
"",
"",
134 "r0b0",
"r1b0",
"r2b0",
"r3b0",
"r4b0",
"r5b0",
"r6b0",
"r7b0",
135 "r0b1",
"r1b1",
"r2b1",
"r3b1",
"r4b1",
"r5b1",
"r6b1",
"r7b1",
138 if (reg_nr >= ARRAY_SIZE (register_names))
140 return register_names[reg_nr];
146 static const char *register_names[] = {
147 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
148 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
149 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
151 "fr0",
"fr1",
"fr2",
"fr3",
"fr4",
"fr5",
"fr6",
"fr7",
152 "fr8",
"fr9",
"fr10",
"fr11",
"fr12",
"fr13",
"fr14",
"fr15",
154 "r0b0",
"r1b0",
"r2b0",
"r3b0",
"r4b0",
"r5b0",
"r6b0",
"r7b0",
155 "r0b1",
"r1b1",
"r2b1",
"r3b1",
"r4b1",
"r5b1",
"r6b1",
"r7b1",
157 if (reg_nr >= ARRAY_SIZE (register_names))
159 return register_names[reg_nr];
165 static const char *register_names[] = {
166 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
167 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
168 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
170 "fr0",
"fr1",
"fr2",
"fr3",
"fr4",
"fr5",
"fr6",
"fr7",
171 "fr8",
"fr9",
"fr10",
"fr11",
"fr12",
"fr13",
"fr14",
"fr15",
173 if (reg_nr >= ARRAY_SIZE (register_names))
175 return register_names[reg_nr];
181 static const char *register_names[] = {
183 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
184 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
186 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
190 "fr0",
"fr1",
"fr2",
"fr3",
"fr4",
"fr5",
"fr6",
"fr7",
191 "fr8",
"fr9",
"fr10",
"fr11",
"fr12",
"fr13",
"fr14",
"fr15",
196 "r0b",
"r1b",
"r2b",
"r3b",
"r4b",
"r5b",
"r6b",
"r7b",
197 "r8b",
"r9b",
"r10b",
"r11b",
"r12b",
"r13b",
"r14b",
198 "machb",
"ivnb",
"prb",
"gbrb",
"maclb",
205 "ibcr",
"ibnr",
"tbr",
209 "dr0",
"dr2",
"dr4",
"dr6",
"dr8",
"dr10",
"dr12",
"dr14",
211 if (reg_nr >= ARRAY_SIZE (register_names))
213 return register_names[reg_nr];
219 static const char *register_names[] = {
221 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
222 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
224 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
228 "",
"",
"",
"",
"",
"",
"",
"",
229 "",
"",
"",
"",
"",
"",
"",
"",
234 "r0b",
"r1b",
"r2b",
"r3b",
"r4b",
"r5b",
"r6b",
"r7b",
235 "r8b",
"r9b",
"r10b",
"r11b",
"r12b",
"r13b",
"r14b",
236 "machb",
"ivnb",
"prb",
"gbrb",
"maclb",
243 "ibcr",
"ibnr",
"tbr",
248 if (reg_nr >= ARRAY_SIZE (register_names))
250 return register_names[reg_nr];
256 static const char *register_names[] = {
257 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
258 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
259 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
261 "a0g",
"a0",
"a1g",
"a1",
"m0",
"m1",
"x0",
"x1",
262 "y0",
"y1",
"",
"",
"",
"",
"",
"mod",
266 if (reg_nr >= ARRAY_SIZE (register_names))
268 return register_names[reg_nr];
274 static const char *register_names[] = {
275 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
276 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
277 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
279 "a0g",
"a0",
"a1g",
"a1",
"m0",
"m1",
"x0",
"x1",
280 "y0",
"y1",
"",
"",
"",
"",
"",
"mod",
282 "rs",
"re",
"",
"",
"",
"",
"",
"",
283 "r0b",
"r1b",
"r2b",
"r3b",
"r4b",
"r5b",
"r6b",
"r7b",
285 if (reg_nr >= ARRAY_SIZE (register_names))
287 return register_names[reg_nr];
293 static const char *register_names[] = {
295 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
296 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
298 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
302 "fr0",
"fr1",
"fr2",
"fr3",
"fr4",
"fr5",
"fr6",
"fr7",
303 "fr8",
"fr9",
"fr10",
"fr11",
"fr12",
"fr13",
"fr14",
"fr15",
307 "r0b0",
"r1b0",
"r2b0",
"r3b0",
"r4b0",
"r5b0",
"r6b0",
"r7b0",
309 "r0b1",
"r1b1",
"r2b1",
"r3b1",
"r4b1",
"r5b1",
"r6b1",
"r7b1",
311 "",
"",
"",
"",
"",
"",
"",
"",
315 "dr0",
"dr2",
"dr4",
"dr6",
"dr8",
"dr10",
"dr12",
"dr14",
317 "fv0",
"fv4",
"fv8",
"fv12",
321 if (reg_nr >= ARRAY_SIZE (register_names))
323 return register_names[reg_nr];
329 static const char *register_names[] = {
331 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
332 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
334 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
338 "",
"",
"",
"",
"",
"",
"",
"",
339 "",
"",
"",
"",
"",
"",
"",
"",
343 "r0b0",
"r1b0",
"r2b0",
"r3b0",
"r4b0",
"r5b0",
"r6b0",
"r7b0",
345 "r0b1",
"r1b1",
"r2b1",
"r3b1",
"r4b1",
"r5b1",
"r6b1",
"r7b1",
347 "",
"",
"",
"",
"",
"",
"",
"",
351 "",
"",
"",
"",
"",
"",
"",
"",
355 if (reg_nr >= ARRAY_SIZE (register_names))
357 return register_names[reg_nr];
363 static const char *register_names[] = {
364 "r0",
"r1",
"r2",
"r3",
"r4",
"r5",
"r6",
"r7",
365 "r8",
"r9",
"r10",
"r11",
"r12",
"r13",
"r14",
"r15",
366 "pc",
"pr",
"gbr",
"vbr",
"mach",
"macl",
"sr",
368 "a0g",
"a0",
"a1g",
"a1",
"m0",
"m1",
"x0",
"x1",
369 "y0",
"y1",
"",
"",
"",
"",
"",
"mod",
371 "rs",
"re",
"",
"",
"",
"",
"",
"",
372 "r0b",
"r1b",
"r2b",
"r3b",
"r4b",
"r5b",
"r6b",
"r7b",
374 if (reg_nr >= ARRAY_SIZE (register_names))
376 return register_names[reg_nr];
389static const gdb_byte *
397 static unsigned char big_remote_breakpoint[] = { 0xc3, 0x20 };
398 static unsigned char little_remote_breakpoint[] = { 0x20, 0xc3 };
401 return big_remote_breakpoint;
403 return little_remote_breakpoint;
409 static unsigned char breakpoint[] = { 0xc3, 0xc3 };
424#define GET_SOURCE_REG(x) (((x) >> 4) & 0xf)
425#define GET_TARGET_REG(x) (((x) >> 8) & 0xf)
428#define IS_JSR(x) (((x) & 0xf0ff) == 0x400b)
432#define IS_STS(x) ((x) == 0x4f22)
436#define IS_MACL_STS(x) ((x) == 0x4f12)
440#define IS_PUSH(x) (((x) & 0xff0f) == 0x2f06)
444#define IS_MOV_SP_FP(x) ((x) == 0x6ef3)
448#define IS_ADD_IMM_SP(x) (((x) & 0xff00) == 0x7f00)
450#define IS_MOV_R3(x) (((x) & 0xff00) == 0x1a00)
451#define IS_SHLL_R3(x) ((x) == 0x4300)
455#define IS_ADD_R3SP(x) ((x) == 0x3f3c)
463#define IS_FPUSH(x) (((x) & 0xff0f) == 0xff0b)
466#define IS_MOV_ARG_TO_REG(x) \
467 (((x) & 0xf00f) == 0x6003 && \
468 ((x) & 0x00f0) >= 0x0040 && \
469 ((x) & 0x00f0) <= 0x0070)
471#define IS_MOV_ARG_TO_IND_R14(x) \
472 (((x) & 0xff0f) == 0x2e02 && \
473 ((x) & 0x00f0) >= 0x0040 && \
474 ((x) & 0x00f0) <= 0x0070)
476#define IS_MOV_ARG_TO_IND_R14_WITH_DISP(x) \
477 (((x) & 0xff00) == 0x1e00 && \
478 ((x) & 0x00f0) >= 0x0040 && \
479 ((x) & 0x00f0) <= 0x0070)
482#define IS_MOVW_PCREL_TO_REG(x) (((x) & 0xf000) == 0x9000)
484#define IS_MOVL_PCREL_TO_REG(x) (((x) & 0xf000) == 0xd000)
486#define IS_MOVI20(x) (((x) & 0xf00f) == 0x0000)
488#define IS_SUB_REG_FROM_SP(x) (((x) & 0xff0f) == 0x3f08)
490#define FPSCR_SZ (1 << 20)
493#define IS_RESTORE_FP(x) ((x) == 0x6ef6)
494#define IS_RTS(x) ((x) == 0x000b)
495#define IS_LDS(x) ((x) == 0x4f26)
496#define IS_MACL_LDS(x) ((x) == 0x4f16)
497#define IS_MOV_FP_SP(x) ((x) == 0x6fe3)
498#define IS_ADD_REG_TO_FP(x) (((x) & 0xff0f) == 0x3e0c)
499#define IS_ADD_IMM_FP(x) (((x) & 0xff00) == 0x7e00)
503 CORE_ADDR pc, CORE_ADDR limit_pc,
511 int reg, sav_reg = -1;
514 for (; pc < limit_pc; pc += 2)
535 r3_val = ((inst & 0xff) ^ 0x80) - 0x80;
547 offset = ((inst & 0xff) ^ 0x80) - 0x80;
558 offset = (inst & 0xff) << 1;
572 offset = (inst & 0xff) << 2;
580 && (pc + 2 < limit_pc))
595 if (sav_offset & 0x00080000)
596 sav_offset |= 0xfff00000;
603 if (sav_reg > 0 && reg == sav_reg)
624 limit_pc = std::min (limit_pc, pc + (2 * 6));
632 for (; pc < limit_pc; pc += 2)
644 offset = (inst & 0xf) * 4;
664 if (pc + 2 < limit_pc)
688 CORE_ADDR post_prologue_pc, func_addr, func_end_addr, limit_pc;
697 if (post_prologue_pc != 0)
698 return std::max (
pc, post_prologue_pc);
710 limit_pc =
pc + (2 * 28);
714 if (func_end_addr != 0)
715 limit_pc = std::min (limit_pc, func_end_addr);
720 pc = post_prologue_pc;
779 if (renesas_abi && (
type->
code () == TYPE_CODE_STRUCT
780 ||
type->
code () == TYPE_CODE_UNION))
785 if (len != 1 && len != 2 && len != 4 && len != 8)
876static const gdb_byte *
879 static gdb_byte valbuf[4];
881 memset (valbuf, 0,
sizeof (valbuf));
886 memcpy (valbuf + (4 - len), val->
contents ().data (), len);
888 memcpy (valbuf, val->
contents ().data (), len);
900 stack_alloc += ((args[nargs]->type ()->length () + 3) & ~3);
1003 if (
type->
code () == TYPE_CODE_FLT)
1006 if (
type->
code () != TYPE_CODE_STRUCT)
1021 struct value *function,
1023 CORE_ADDR bp_addr,
int nargs,
1024 struct value **args,
1026 CORE_ADDR struct_addr)
1029 int stack_offset = 0;
1036 const gdb_byte *val;
1037 int len, reg_size = 0;
1040 int last_reg_arg = INT_MAX;
1047 last_reg_arg =
func_type->num_fields () - 2;
1061 for (argnum = 0; argnum < nargs; argnum++)
1063 type = args[argnum]->type ();
1078 && ((
type->
code () == TYPE_CODE_INT && len == 8)
1079 ||
type->
code () == TYPE_CODE_STRUCT
1080 ||
type->
code () == TYPE_CODE_UNION))
1093 || argnum > last_reg_arg)
1096 reg_size = (len + 3) & ~3;
1098 stack_offset += reg_size;
1163 struct value *function,
1166 int nargs,
struct value **args,
1169 CORE_ADDR struct_addr)
1172 int stack_offset = 0;
1178 const gdb_byte *val;
1179 int len, reg_size = 0;
1181 int last_reg_arg = INT_MAX;
1188 last_reg_arg =
func_type->num_fields () - 2;
1199 for (argnum = 0; argnum < nargs; argnum++)
1201 type = args[argnum]->type ();
1211 && ((
type->
code () == TYPE_CODE_INT && len >= 8)
1212 || (
type->
code () == TYPE_CODE_FLT && len >= 8)
1213 ||
type->
code () == TYPE_CODE_STRUCT
1214 ||
type->
code () == TYPE_CODE_UNION))
1219 || argnum > last_reg_arg)
1223 reg_size = (len + 3) & ~3;
1225 stack_offset += reg_size;
1287 for (i = 0; i < len; i += 4)
1291 error (_(
"bad size for return value"));
1303 for (i = 0; i < len; i += 4)
1306 valbuf + len - 4 - i);
1322 const gdb_byte *valbuf)
1337 for (i = 0; i < len; i += 4)
1344 const gdb_byte *valbuf)
1351 for (i = 0; i < len; i += 4)
1354 valbuf + len - 4 - i);
1365 gdb_byte *readbuf,
const gdb_byte *writebuf)
1382 gdb_byte *readbuf,
const gdb_byte *writebuf)
1531 struct type *
type, gdb_byte *from, gdb_byte *to)
1545 (
"sh_register_convert_to_virtual called with non DR register number");
1550 int regnum,
const gdb_byte *from, gdb_byte *to)
1563 error (_(
"sh_register_convert_to_raw called with non DR register number"));
1591static enum register_status
1595 int base_regnum, gdb_byte *buffer)
1599 for (portion = 0; portion < portions; portion++)
1601 enum register_status
status;
1613static enum register_status
1615 int reg_nr, gdb_byte *buffer)
1618 enum register_status
status;
1625 gdb_byte temp_buffer[4 * 2];
1631 2, base_regnum, temp_buffer);
1637 temp_buffer, buffer);
1647 4, base_regnum, buffer);
1650 gdb_assert_not_reached (
"invalid pseudo register number");
1655 int reg_nr,
const gdb_byte *buffer)
1657 int base_regnum, portion;
1674 gdb_byte temp_buffer[4 * 2];
1679 reg_nr, buffer, temp_buffer);
1682 for (portion = 0; portion < 2; portion++)
1686 base_regnum) * portion));
1693 for (portion = 0; portion < 4; portion++)
1697 base_regnum) * portion));
1709 return SIM_SH_MOD_REGNUM;
1711 return SIM_SH_RS_REGNUM;
1713 return SIM_SH_RE_REGNUM;
1725 return SIM_SH_TBR_REGNUM;
1727 return SIM_SH_IBNR_REGNUM;
1729 return SIM_SH_IBCR_REGNUM;
1731 return SIM_SH_BANK_REGNUM;
1733 return SIM_SH_BANK_MACL_REGNUM;
1735 return SIM_SH_BANK_GBR_REGNUM;
1737 return SIM_SH_BANK_PR_REGNUM;
1739 return SIM_SH_BANK_IVN_REGNUM;
1741 return SIM_SH_BANK_MACH_REGNUM;
1832 CORE_ADDR current_pc;
1839 *this_cache = cache;
1847 if (cache->
base == 0)
1894static struct value *
1896 void **this_cache,
int regnum)
1901 gdb_assert (
regnum >= 0);
1926 if (cache->
base == 0)
1977 if (*this_cache == NULL)
1987 void **this_prologue_cache)
1989 CORE_ADDR addr_in_block;
2019 CORE_ADDR func_addr = 0, func_end = 0;
2028 CORE_ADDR addr = func_end - 28;
2029 if (addr < func_addr + 4)
2030 addr = func_addr + 4;
2035 while (addr < func_end
2038 if (addr >= func_end)
2077 while (addr > func_addr + 4
2088 && addr > func_addr + 6
2108 int regnum,
const void *regs,
size_t len)
2117 for (i = 0;
regmap[i].regnum != -1; i++)
2120 &&
regmap[i].offset + 4 <= len)
2134 int regnum,
void *regs,
size_t len)
2143 for (i = 0;
regmap[i].regnum != -1; i++)
2146 &&
regmap[i].offset + 4 <= len)
2148 (
char *)regs +
regmap[i].offset);
2259 switch (
info.bfd_arch_info->mach)
2294 case bfd_mach_sh2a_nofpu:
2303 case bfd_mach_sh_dsp:
2309 case bfd_mach_sh3_nommu:
2310 case bfd_mach_sh2a_nofpu_or_sh3_nommu:
2315 case bfd_mach_sh2a_or_sh3e:
2327 case bfd_mach_sh3_dsp:
2334 case bfd_mach_sh2a_or_sh4:
2345 case bfd_mach_sh4_nofpu:
2346 case bfd_mach_sh4a_nofpu:
2347 case bfd_mach_sh4_nommu_nofpu:
2348 case bfd_mach_sh2a_nofpu_or_sh4_nommu_nofpu:
2352 case bfd_mach_sh4al_dsp:
2379 _(
"SH specific commands."),
2380 _(
"SH specific commands."),
2386 _(
"Set calling convention used when calling target "
2387 "functions from GDB."),
2388 _(
"Show calling convention used when calling target "
2389 "functions from GDB."),
2390 _(
"gcc - Use GCC calling convention (default).\n"
2391 "renesas - Enforce Renesas calling convention."),
static void pass_on_stack(struct aarch64_call_info *info, struct type *type, struct value *arg)
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 legacy_register_sim_regno(struct gdbarch *gdbarch, int regnum)
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)
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)
void invalidate(int regnum)
void raw_collect(int regnum, void *buf) const override
void raw_supply(int regnum, const void *buf) override
void raw_write(int regnum, const gdb_byte *buf)
struct cmd_list_element * showlist
struct cmd_list_element * setlist
set_show_commands add_setshow_enum_cmd(const char *name, enum command_class theclass, const char *const *enumlist, const char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
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)
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
LONGEST read_memory_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_STRUCT_CONVENTION
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
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_SAME_VALUE
@ DWARF2_FRAME_REG_UNDEFINED
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)
CORE_ADDR get_frame_func(frame_info_ptr this_frame)
CORE_ADDR get_frame_address_in_block(frame_info_ptr this_frame)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
int gdbarch_pc_regnum(struct gdbarch *gdbarch)
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_register_sim_regno(struct gdbarch *gdbarch, gdbarch_register_sim_regno_ftype *register_sim_regno)
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
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_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_int_bit(struct gdbarch *gdbarch, int int_bit)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_return_in_first_hidden_param_p(struct gdbarch *gdbarch, gdbarch_return_in_first_hidden_param_p_ftype *return_in_first_hidden_param_p)
void set_gdbarch_believe_pcc_promotion(struct gdbarch *gdbarch, int believe_pcc_promotion)
void set_gdbarch_wchar_signed(struct gdbarch *gdbarch, int wchar_signed)
void set_gdbarch_fp0_regnum(struct gdbarch *gdbarch, int fp0_regnum)
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
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_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype *register_reggroup_p)
int gdbarch_sp_regnum(struct gdbarch *gdbarch)
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype *register_type)
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
void set_gdbarch_stack_frame_destroyed_p(struct gdbarch *gdbarch, gdbarch_stack_frame_destroyed_p_ftype *stack_frame_destroyed_p)
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
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)
int gdbarch_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
int gdbarch_fp0_regnum(struct gdbarch *gdbarch)
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)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
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)
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
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)
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_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
const struct floatformat * floatformats_ieee_double_littlebyte_bigword[BFD_ENDIAN_UNKNOWN]
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
struct type * init_float_type(type_allocator &alloc, int bit, const char *name, const struct floatformat **floatformats, enum bfd_endian byte_order)
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
struct type * check_typedef(struct type *type)
#define TYPE_CALLING_CONVENTION(thistype)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
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)
struct type * register_type(struct gdbarch *gdbarch, int regnum)
const reggroup *const general_reggroup
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
const reggroup *const system_reggroup
const reggroup *const float_reggroup
const reggroup *const all_reggroup
const reggroup *const vector_reggroup
static const char sh_cc_gcc[]
static const char * sh_sh_register_name(struct gdbarch *gdbarch, int reg_nr)
static struct type * sh_sh4_build_float_register_type(struct gdbarch *gdbarch, int high)
static int sh_use_struct_convention(int renesas_abi, struct type *type)
#define GET_SOURCE_REG(x)
static const struct frame_unwind sh_frame_unwind
static enum return_value_convention sh_return_value_nofpu(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
#define IS_MOV_ARG_TO_IND_R14_WITH_DISP(x)
static const char * sh_active_calling_convention
static CORE_ADDR sh_frame_base_address(frame_info_ptr this_frame, void **this_cache)
static const char * sh_sh3_dsp_register_name(struct gdbarch *gdbarch, int reg_nr)
#define IS_ADD_REG_TO_FP(x)
static void sh_extract_return_value_fpu(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static int sh_stack_frame_destroyed_p(struct gdbarch *gdbarch, CORE_ADDR pc)
#define IS_SUB_REG_FROM_SP(x)
static CORE_ADDR sh_push_dummy_call_nofpu(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 sh_return_in_first_hidden_param_p(struct gdbarch *gdbarch, struct type *type)
static CORE_ADDR sh_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static void sh_register_convert_to_virtual(struct gdbarch *gdbarch, int regnum, struct type *type, gdb_byte *from, gdb_byte *to)
static int dr_reg_base_num(struct gdbarch *gdbarch, int dr_regnum)
static const char * sh_sh3e_register_name(struct gdbarch *gdbarch, int reg_nr)
static const char sh_cc_renesas[]
static void sh_frame_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static const char * sh_sh2a_nofpu_register_name(struct gdbarch *gdbarch, int reg_nr)
static CORE_ADDR sh_push_dummy_call_fpu(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 const gdb_byte * sh_justify_value_in_reg(struct gdbarch *gdbarch, struct value *val, int len)
#define IS_MOVL_PCREL_TO_REG(x)
#define GET_TARGET_REG(x)
static struct sh_frame_cache * sh_frame_cache(frame_info_ptr this_frame, void **this_cache)
static void sh_store_return_value_fpu(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static const char * sh_sh4_nofpu_register_name(struct gdbarch *gdbarch, int reg_nr)
static CORE_ADDR sh_frame_align(struct gdbarch *ignore, CORE_ADDR sp)
#define IS_MOV_ARG_TO_IND_R14(x)
static struct type * sh_littlebyte_bigword_type(struct gdbarch *gdbarch)
#define IS_MOVW_PCREL_TO_REG(x)
static CORE_ADDR sh_stack_allocsize(int nargs, struct value **args)
static int sh_is_renesas_calling_convention(struct type *func_type)
static const char * sh_sh3_register_name(struct gdbarch *gdbarch, int reg_nr)
static const gdb_byte * sh_sw_breakpoint_from_kind(struct gdbarch *gdbarch, int kind, int *size)
static void sh_stub_this_id(frame_info_ptr this_frame, void **this_cache, struct frame_id *this_id)
static struct type * sh_sh4_register_type(struct gdbarch *gdbarch, int reg_nr)
static int sh_dsp_register_sim_regno(struct gdbarch *gdbarch, int nr)
static struct gdbarch * sh_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static int sh_sh2a_register_sim_regno(struct gdbarch *gdbarch, int nr)
static const char * sh_sh_dsp_register_name(struct gdbarch *gdbarch, int reg_nr)
static int fv_reg_base_num(struct gdbarch *gdbarch, int fv_regnum)
static enum return_value_convention sh_return_value_fpu(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static int sh_breakpoint_kind_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr)
static struct type * sh_sh3e_register_type(struct gdbarch *gdbarch, int reg_nr)
static int sh_treat_as_flt_p(struct type *type)
static struct sh_frame_cache * sh_alloc_frame_cache(void)
static const struct frame_unwind sh_stub_unwind
static void sh_init_flt_argreg(void)
static const char * sh_sh2e_register_name(struct gdbarch *gdbarch, int reg_nr)
static CORE_ADDR sh_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, CORE_ADDR limit_pc, struct sh_frame_cache *cache, ULONGEST fpscr)
static void sh_register_convert_to_raw(struct gdbarch *gdbarch, struct type *type, int regnum, const gdb_byte *from, gdb_byte *to)
static int sh_next_flt_argreg(struct gdbarch *gdbarch, int len, struct type *func_type)
void _initialize_sh_tdep()
static struct type * sh_sh2a_register_type(struct gdbarch *gdbarch, int reg_nr)
static const struct regset sh_corefile_fpregset
static enum register_status sh_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int reg_nr, gdb_byte *buffer)
void sh_corefile_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs, size_t len)
void sh_corefile_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *regs, size_t len)
static struct sh_frame_cache * sh_make_stub_cache(frame_info_ptr this_frame)
static struct type * sh_default_register_type(struct gdbarch *gdbarch, int reg_nr)
static int sh_use_struct_convention_nofpu(int renesas_abi, struct type *type)
static void sh_store_return_value_nofpu(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static int sh_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *reggroup)
static struct cmd_list_element * showshcmdlist
static int sh_stub_unwind_sniffer(const struct frame_unwind *self, frame_info_ptr this_frame, void **this_prologue_cache)
static const char * sh_sh4_register_name(struct gdbarch *gdbarch, int reg_nr)
#define IS_MOV_ARG_TO_REG(x)
static const char * sh_sh2a_register_name(struct gdbarch *gdbarch, int reg_nr)
static void sh_extract_return_value_nofpu(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static const struct frame_base sh_frame_base
const struct regset sh_corefile_gregset
static int flt_argreg_array[FLOAT_ARGLAST_REGNUM - FLOAT_ARG0_REGNUM+1]
static void sh_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
static struct cmd_list_element * setshcmdlist
static void sh_dwarf2_frame_init_reg(struct gdbarch *gdbarch, int regnum, struct dwarf2_frame_state_reg *reg, frame_info_ptr this_frame)
static void sh_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg_nr, const gdb_byte *buffer)
static const char *const sh_cc_enum[]
static struct value * sh_frame_prev_register(frame_info_ptr this_frame, void **this_cache, int regnum)
static const char * sh_sh4al_dsp_register_name(struct gdbarch *gdbarch, int reg_nr)
static enum register_status pseudo_register_read_portions(struct gdbarch *gdbarch, readable_regcache *regcache, int portions, int base_regnum, gdb_byte *buffer)
struct type * builtin_double
struct type * builtin_int
struct type * builtin_float
enum dwarf2_frame_reg_rule how
struct type * type() const
CORE_ADDR saved_regs[SH_NUM_REGS]
struct sh_corefile_regmap * core_fpregmap
struct sh_corefile_regmap * core_gregmap
struct type * sh_littlebyte_bigword_type
struct field & field(int idx) const
unsigned int num_fields() const
gdb::array_view< const gdb_byte > contents()
struct type * type() const
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
void target_float_convert(const gdb_byte *from, const struct type *from_type, gdb_byte *to, const struct type *to_type)
const char * target_shortname()