45#include "cgen/bitset.h"
51#include "opcodes/mep-desc.h"
52#include "opcodes/mep-opc.h"
155static const CGEN_HW_ENTRY *
158 CGEN_BITSET *copro_isa_mask,
159 CGEN_BITSET *generic_isa_mask)
161 int prefix_len = strlen (
prefix);
164 for (i = 0; i < desc->hw_table.num_entries; i++)
166 const CGEN_HW_ENTRY *hw = desc->hw_table.entries[i];
167 if (strncmp (
prefix, hw->name, prefix_len) == 0)
169 CGEN_BITSET *hw_isa_mask
171 &CGEN_ATTR_CGEN_HW_ISA_VALUE (CGEN_HW_ATTRS (hw)));
173 if (cgen_bitset_intersect_p (hw_isa_mask, copro_isa_mask)
174 && ! cgen_bitset_intersect_p (hw_isa_mask, generic_isa_mask))
185static const CGEN_HW_ENTRY *
190 for (i = 0; i < desc->hw_table.num_entries; i++)
192 const CGEN_HW_ENTRY *hw = desc->hw_table.entries[i];
194 if (hw->type ==
type)
207static const CGEN_HW_ENTRY *
210 CGEN_HW_TYPE generic_type)
264 CGEN_CPU_DESC desc = tdep->
cpu_desc;
265 const CGEN_HW_ENTRY *hw;
267 if (me_module == CONFIG_NONE)
271 CGEN_BITSET *cop = &mep_config_map[me_module].cop_isa;
272 CGEN_BITSET *core = &mep_config_map[me_module].core_isa;
273 CGEN_BITSET *
generic = &mep_config_map[CONFIG_NONE].core_isa;
274 CGEN_BITSET *cop_and_core;
278 cop_and_core = cgen_bitset_copy (cop);
279 cgen_bitset_union (cop, core, cop_and_core);
298 gdb_assert (hw->asm_type == CGEN_ASM_KEYWORD);
302 return (CGEN_KEYWORD *) hw->asm_data;
312 const CGEN_KEYWORD_ENTRY *entry
313 = cgen_keyword_lookup_value (keyword_table,
regnum);
317 char *
name = entry->name;
362 unsigned int opt_bit, option_mask_bit;
367 {
MEP_OPT_DBG, 1 << CGEN_INSN_OPTIONAL_DEBUG_INSN },
371 {
MEP_OPT_MIN, 1 << CGEN_INSN_OPTIONAL_MINMAX_INSN },
372 {
MEP_OPT_CLP, 1 << CGEN_INSN_OPTIONAL_CLIP_INSN },
380 unsigned int opt = 0;
382 for (i = 0; i < (
sizeof (
bits) /
sizeof (
bits[0])); i++)
383 if (option_mask &
bits[i].option_mask_bit)
384 opt |=
bits[i].opt_bit;
404 if (mep_config_map[me_module].option_mask
405 & (1 << CGEN_INSN_OPTIONAL_CP64_INSN))
416 return mep_config_map[me_module].big_endian;
426 if (! mep_config_map[me_module].
name
427 || mep_config_map[me_module].
name[0] ==
'\0')
430 return mep_config_map[me_module].name;
615#define IN_SET(set, n) \
616 (MEP_FIRST_ ## set ## _REGNUM <= (n) && (n) <= MEP_LAST_ ## set ## _REGNUM)
618#define IS_GPR_REGNUM(n) (IN_SET (GPR, (n)))
619#define IS_RAW_CSR_REGNUM(n) (IN_SET (RAW_CSR, (n)))
620#define IS_RAW_CR_REGNUM(n) (IN_SET (RAW_CR, (n)))
621#define IS_RAW_CCR_REGNUM(n) (IN_SET (RAW_CCR, (n)))
623#define IS_CSR_REGNUM(n) (IN_SET (CSR, (n)))
624#define IS_CR32_REGNUM(n) (IN_SET (CR32, (n)))
625#define IS_FP_CR32_REGNUM(n) (IN_SET (FP_CR32, (n)))
626#define IS_CR64_REGNUM(n) (IN_SET (CR64, (n)))
627#define IS_FP_CR64_REGNUM(n) (IN_SET (FP_CR64, (n)))
628#define IS_CR_REGNUM(n) (IS_CR32_REGNUM (n) || IS_FP_CR32_REGNUM (n) \
629 || IS_CR64_REGNUM (n) || IS_FP_CR64_REGNUM (n))
630#define IS_CCR_REGNUM(n) (IN_SET (CCR, (n)))
632#define IS_RAW_REGNUM(n) (IN_SET (RAW, (n)))
633#define IS_PSEUDO_REGNUM(n) (IN_SET (PSEUDO, (n)))
635#define NUM_REGS_IN_SET(set) \
636 (MEP_LAST_ ## set ## _REGNUM - MEP_FIRST_ ## set ## _REGNUM + 1)
638#define MEP_GPR_SIZE (4)
639#define MEP_PSW_SIZE (4)
640#define MEP_LP_SIZE (4)
665#define CSR(name) MEP_RAW_ ## name ## _REGNUM, MEP_ ## name ## _REGNUM
667 {
CSR(
PC), 0xffffffff },
668 {
CSR(LP), 0xffffffff },
669 {
CSR(SAR), 0x0000003f },
670 {
CSR(CSR3), 0xffffffff },
671 {
CSR(RPB), 0xfffffffe },
672 {
CSR(RPE), 0xffffffff },
673 {
CSR(RPC), 0xffffffff },
674 {
CSR(HI), 0xffffffff },
675 {
CSR(LO), 0xffffffff },
676 {
CSR(CSR9), 0xffffffff },
677 {
CSR(CSR10), 0xffffffff },
678 {
CSR(CSR11), 0xffffffff },
679 {
CSR(MB0), 0x0000ffff },
680 {
CSR(ME0), 0x0000ffff },
681 {
CSR(MB1), 0x0000ffff },
682 {
CSR(ME1), 0x0000ffff },
683 {
CSR(PSW), 0x000003ff },
684 {
CSR(ID), 0x00000000 },
685 {
CSR(TMP), 0xffffffff },
686 {
CSR(EPC), 0xffffffff },
687 {
CSR(EXC), 0x000030f0 },
688 {
CSR(CFG), 0x00c0001b },
689 {
CSR(CSR22), 0xffffffff },
690 {
CSR(NPC), 0xffffffff },
691 {
CSR(DBG), 0x00000580 },
692 {
CSR(DEPC), 0xffffffff },
693 {
CSR(OPT), 0x00000000 },
694 {
CSR(RCFG), 0x00000000 },
695 {
CSR(CCFG), 0x00000000 },
696 {
CSR(CSR29), 0xffffffff },
697 {
CSR(CSR30), 0xffffffff },
698 {
CSR(CSR31), 0xffffffff },
806 gdb_assert_not_reached (
"unexpected coprocessor pseudo register");
835 gdb_assert_not_reached (
"unexpected coprocessor pseudo register");
854 return (CONFIG_ATTR) regval;
902 const CGEN_HW_ENTRY *hw
914 const CGEN_HW_ENTRY *hw
917 return CGEN_ATTR_CGEN_HW_IS_FLOAT_VALUE (CGEN_HW_ATTRS (hw));
926 const CGEN_HW_ENTRY *hw
937 static const char *gpr_names[] = {
938 "r0",
"r1",
"r2",
"r3",
939 "r4",
"r5",
"r6",
"r7",
940 "fp",
"r9",
"r10",
"r11",
941 "r12",
"tp",
"gp",
"sp"
945 static const char *csr_names[] = {
946 "pc",
"lp",
"sar",
"",
947 "rpb",
"rpe",
"rpc",
"hi",
949 "mb0",
"me0",
"mb1",
"me1",
951 "psw",
"id",
"tmp",
"epc",
952 "exc",
"cfg",
"",
"npc",
953 "dbg",
"depc",
"opt",
"rcfg",
1105 else if (
size == 64)
1113 gdb_assert_not_reached (
"unexpected cr size");
1121static enum register_status
1127 enum register_status
status;
1147static enum register_status
1157static enum register_status
1173 gdb_assert_not_reached (
"unexpected pseudo register");
1181 const gdb_byte *buf)
1197 ULONGEST mixed_bits;
1212 const gdb_byte *buf)
1233 const gdb_byte *buf)
1243 const gdb_byte *buf)
1256 gdb_assert_not_reached (
"unexpected pseudo register");
1268 info->arch = bfd_arch_mep;
1278 return print_insn_mep (pc, info);
1412 int pc_in_vliw_section;
1421 if (pc_in_vliw_section)
1454 if ((*insn & 0xc0000000) == 0xc0000000)
1477 gdb_assert_not_reached (
"unexpected vliw mode");
1482 else if ((*insn & 0xc0000000) == 0xc0000000)
1487 return pc + insn_len;
1492#define SEXT(n, len) ((((int) (n)) ^ (1 << ((len) - 1))) - (1 << ((len) - 1)))
1495#define FIELD(i, pos, len) (((i) >> (pos)) & ((1 << (len)) - 1))
1498#define SFIELD(i, pos, len) (SEXT (FIELD ((i), (pos), (len)), (len)))
1514#define IS_SW(i) (((i) & 0xf00f0000) == 0xc00a0000)
1516#define IS_SB(i) (((i) & 0xf00f0000) == 0xc0080000)
1518#define IS_SH(i) (((i) & 0xf00f0000) == 0xc0090000)
1519#define SWBH_32_BASE(i) (FIELD (i, 20, 4))
1520#define SWBH_32_SOURCE(i) (FIELD (i, 24, 4))
1521#define SWBH_32_OFFSET(i) (SFIELD (i, 0, 16))
1524#define IS_SW_IMMD(i) (((i) & 0xf0830000) == 0x40020000)
1525#define SW_IMMD_SOURCE(i) (FIELD (i, 24, 4))
1526#define SW_IMMD_OFFSET(i) (FIELD (i, 18, 5) << 2)
1529#define IS_SW_REG(i) (((i) & 0xf00f0000) == 0x000a0000)
1530#define SW_REG_SOURCE(i) (FIELD (i, 24, 4))
1531#define SW_REG_BASE(i) (FIELD (i, 20, 4))
1534#define IS_ADD3_16_REG(i) (((i) & 0xf0000000) == 0x90000000)
1535#define ADD3_16_REG_SRC1(i) (FIELD (i, 20, 4))
1536#define ADD3_16_REG_SRC2(i) (FIELD (i, 24, 4))
1539#define IS_ADD3_32(i) (((i) & 0xf00f0000) == 0xc0000000)
1540#define ADD3_32_TARGET(i) (FIELD (i, 24, 4))
1541#define ADD3_32_SOURCE(i) (FIELD (i, 20, 4))
1542#define ADD3_32_OFFSET(i) (SFIELD (i, 0, 16))
1545#define IS_ADD3_16(i) (((i) & 0xf0830000) == 0x40000000)
1546#define ADD3_16_TARGET(i) (FIELD (i, 24, 4))
1547#define ADD3_16_OFFSET(i) (FIELD (i, 18, 5) << 2)
1550#define IS_ADD(i) (((i) & 0xf0030000) == 0x60000000)
1551#define ADD_TARGET(i) (FIELD (i, 24, 4))
1552#define ADD_OFFSET(i) (SFIELD (i, 18, 6))
1556#define IS_LDC(i) (((i) & 0xf00e0000) == 0x700a0000)
1557#define LDC_IMM(i) ((FIELD (i, 16, 1) << 4) | FIELD (i, 20, 4))
1558#define LDC_TARGET(i) (FIELD (i, 24, 4))
1561#define IS_LW(i) (((i) & 0xf00f0000) == 0xc00e0000)
1562#define LW_TARGET(i) (FIELD (i, 24, 4))
1563#define LW_BASE(i) (FIELD (i, 20, 4))
1564#define LW_OFFSET(i) (SFIELD (i, 0, 16))
1567#define IS_MOV(i) (((i) & 0xf00f0000) == 0x00000000)
1568#define MOV_TARGET(i) (FIELD (i, 24, 4))
1569#define MOV_SOURCE(i) (FIELD (i, 20, 4))
1572#define IS_BRA(i) (((i) & 0xf0010000) == 0xb0000000)
1573#define BRA_DISP(i) (SFIELD (i, 17, 11) << 1)
1665 CORE_ADDR start_pc, CORE_ADDR limit_pc,
1671 CORE_ADDR after_last_frame_setup_insn = start_pc;
1673 memset (result, 0,
sizeof (*result));
1685 while (pc < limit_pc)
1688 pv_t pre_insn_fp, pre_insn_sp;
1738 after_last_frame_setup_insn = next_pc;
1740 stack.
store (reg[rm], 4, reg[rn]);
1755 after_last_frame_setup_insn = next_pc;
1757 stack.
store (addr, 4, reg[rn]);
1767 after_last_frame_setup_insn = next_pc;
1776 : (gdb_assert (
IS_SW (insn)), 4));
1783 after_last_frame_setup_insn = next_pc;
1794 else if (
IS_LW (insn))
1801 reg[rn] = stack.
fetch (addr, 4);
1824 after_last_frame_setup_insn = next_pc;
1851 after_last_frame_setup_insn = next_pc;
1862 after_last_frame_setup_insn = next_pc;
1890 CORE_ADDR func_addr, func_end;
1914 void **this_prologue_cache)
1916 if (! *this_prologue_cache)
1918 CORE_ADDR func_start, stop_addr;
1920 *this_prologue_cache
1929 stop_addr = func_start;
1932 func_start, stop_addr,
1944 void **this_prologue_cache)
1947 = mep_analyze_frame_prologue (this_frame, this_prologue_cache);
1972 void **this_prologue_cache,
1980static struct value *
1982 void **this_prologue_cache,
int regnum)
1985 = mep_analyze_frame_prologue (this_frame, this_prologue_cache);
2099 if (byte_order == BFD_ENDIAN_BIG)
2114 const gdb_byte *valbuf)
2126 if (byte_order == BFD_ENDIAN_BIG)
2140GDB cannot set return values larger than four bytes; the Media Processor's\n\
2141calling conventions do not provide enough information to do this.\n\
2142Try using the 'return' command with no argument."));
2148 gdb_byte *readbuf,
const gdb_byte *writebuf)
2167GDB cannot set return values larger than four bytes; the Media Processor's\n\
2168calling conventions do not provide enough information to do this.\n\
2169Try using the 'return' command with no argument."));
2229 for (i = 0; i < argc; i++)
2237 sp = (sp - arg_len) & -4;
2250 int argc,
struct value **argv, CORE_ADDR sp,
2252 CORE_ADDR struct_addr)
2255 CORE_ADDR *copy = (CORE_ADDR *) alloca (argc *
sizeof (copy[0]));
2262 CORE_ADDR arg_stack;
2266 CORE_ADDR arg_stack_end;
2272 if (argc + (struct_addr ? 1 : 0) > 4)
2273 sp -= ((argc + (struct_addr ? 1 : 0)) - 4) *
MEP_GPR_SIZE;
2286 for (i = 0; i < argc; i++)
2316 gdb_assert (arg_stack <= arg_stack_end);
2337 CONFIG_ATTR me_module;
2345 if (bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
2347 int flag = elf_elfheader (info.abfd)->e_flags & EF_MEP_INDEX_MASK;
2348 me_module = (CONFIG_ATTR) flag;
2351 me_module = CONFIG_NONE;
2354 me_module = CONFIG_NONE;
2365 const char *module_endianness
2367 const char *file_name = bfd_get_filename (info.abfd);
2368 const char *file_endianness
2369 = bfd_big_endian (info.abfd) ?
"big" :
"little";
2373 warning (_(
"the MeP module '%s' is %s-endian, but the executable\n"
2374 "%s is %s-endian."),
2375 module_name, module_endianness,
2376 file_name, file_endianness);
2378 warning (_(
"the selected MeP module is %s-endian, but the "
2380 "%s is %s-endian."),
2381 module_endianness, file_name, file_endianness);
2394 = gdbarch_tdep<mep_gdbarch_tdep> (
arches->gdbarch);
2405 const char *mach_name = info.bfd_arch_info->printable_name;
2406 enum cgen_endian endian = (info.byte_order == BFD_ENDIAN_BIG
2408 : CGEN_ENDIAN_LITTLE);
2410 tdep->
cpu_desc = mep_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
2411 CGEN_CPU_OPEN_ENDIAN, endian,
#define bits(obj, st, fn)
struct gdbarch * target_gdbarch(void)
static std::vector< const char * > arches
void gdbarch_register(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init, gdbarch_dump_tdep_ftype *dump_tdep)
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)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
void scan(void(*func)(void *closure, pv_t addr, CORE_ADDR size, pv_t value), void *closure)
pv_t fetch(pv_t addr, CORE_ADDR size)
bool find_reg(struct gdbarch *gdbarch, int reg, CORE_ADDR *offset_p)
bool store_would_trash(pv_t addr)
void store(pv_t addr, CORE_ADDR size, pv_t value)
enum register_status raw_read(int regnum, gdb_byte *buf)
enum register_status cooked_read_part(int regnum, int offset, int len, gdb_byte *buf)
void cooked_write_part(int regnum, int offset, int len, 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)
void read_memory(CORE_ADDR memaddr, gdb_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_ABI_RETURNS_ADDRESS
@ RETURN_VALUE_REGISTER_CONVENTION
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)
struct value * get_frame_register_value(frame_info_ptr frame, int regnum)
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)
#define FRAME_OBSTACK_ZALLOC(TYPE)
void set_gdbarch_stab_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_stab_reg_to_regnum_ftype *stab_reg_to_regnum)
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_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)
int gdbarch_addr_bit(struct gdbarch *gdbarch)
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype *register_name)
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype *return_value)
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
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)
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_print_insn(struct gdbarch *gdbarch, gdbarch_print_insn_ftype *print_insn)
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_dwarf2_reg_to_regnum(struct gdbarch *gdbarch, gdbarch_dwarf2_reg_to_regnum_ftype *dwarf2_reg_to_regnum)
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_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype *sw_breakpoint_from_kind)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep_base *tdep)
function_call_return_method
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
static struct gdbarch * mep_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static int is_arg_reg(pv_t value)
static void mep_store_return_value(struct gdbarch *arch, struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static const char * me_module_name(CONFIG_ATTR me_module)
void _initialize_mep_tdep()
constexpr gdb_byte mep_break_insn[]
static void check_for_saved(void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
static int mep_pseudo_cr_size(int pseudo)
static int mep_pseudo_to_raw[MEP_NUM_REGS]
static CORE_ADDR mep_get_insn(struct gdbarch *gdbarch, CORE_ADDR pc, unsigned long *insn)
static unsigned int opt_from_option_mask(unsigned int option_mask)
#define SW_IMMD_SOURCE(i)
static const reggroup * mep_cr_reggroup
static unsigned int current_options(void)
static void mep_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR start_pc, CORE_ADDR limit_pc, struct mep_prologue *result)
static const reggroup * mep_ccr_reggroup
#define NUM_REGS_IN_SET(set)
static enum return_value_convention mep_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static int mep_pseudo_cr_is_float(int pseudo)
#define SWBH_32_SOURCE(i)
static void mep_extract_return_value(struct gdbarch *arch, struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static CGEN_KEYWORD * register_set_keyword_table(const CGEN_HW_ENTRY *hw)
static const struct frame_unwind mep_frame_unwind
static const reggroup * mep_csr_reggroup
static int mep_register_reggroup_p(struct gdbarch *gdbarch, int regnum, const struct reggroup *group)
static int mep_raw_to_pseudo[MEP_NUM_REGS]
static enum register_status mep_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf)
static CORE_ADDR push_large_arguments(CORE_ADDR sp, int argc, struct value **argv, CORE_ADDR copy[])
static enum register_status mep_pseudo_cr64_read(struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf)
#define IS_FP_CR32_REGNUM(n)
@ MEP_FIRST_RAW_CR_REGNUM
@ MEP_FIRST_FP_CR32_REGNUM
@ MEP_LAST_RAW_CSR_REGNUM
@ MEP_LAST_FP_CR64_REGNUM
@ MEP_LAST_RAW_CCR_REGNUM
@ MEP_FIRST_PSEUDO_REGNUM
@ MEP_FIRST_RAW_CCR_REGNUM
@ MEP_LAST_FP_CR32_REGNUM
@ MEP_FIRST_RAW_CSR_REGNUM
@ MEP_FIRST_FP_CR64_REGNUM
static CORE_ADDR mep_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static struct value * mep_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static CORE_ADDR mep_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
#define ADD3_16_OFFSET(i)
static unsigned int me_module_opt(CONFIG_ATTR me_module)
#define IS_RAW_CR_REGNUM(n)
static int mep_debug_reg_to_regnum(struct gdbarch *gdbarch, int debug_reg)
static const char * mep_register_name(struct gdbarch *gdbarch, int regnr)
static const CGEN_HW_ENTRY * find_hw_entry_by_prefix_and_isa(CGEN_CPU_DESC desc, const char *prefix, CGEN_BITSET *copro_isa_mask, CGEN_BITSET *generic_isa_mask)
static CONFIG_ATTR current_me_module(void)
static const char * register_name_from_keyword(CGEN_KEYWORD *keyword_table, int regnum)
static int current_cop_data_bus_width(void)
static int current_cr_is_float(void)
static enum register_status mep_pseudo_cr32_read(struct gdbarch *gdbarch, readable_regcache *regcache, int cookednum, gdb_byte *buf)
static void mep_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
static int mep_pseudo_cr_index(int pseudo)
#define ADD3_32_OFFSET(i)
#define IS_FP_CR64_REGNUM(n)
#define SWBH_32_OFFSET(i)
#define ADD3_16_TARGET(i)
static int is_arg_spill(struct gdbarch *gdbarch, pv_t value, pv_t addr, struct pv_area *stack)
static void mep_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static int me_module_big_endian(CONFIG_ATTR me_module)
static struct type * mep_register_type(struct gdbarch *gdbarch, int reg_nr)
static CGEN_KEYWORD * current_cr_names(void)
#define ADD3_32_SOURCE(i)
#define SW_IMMD_OFFSET(i)
static int mep_pc_in_vliw_section(CORE_ADDR pc)
static void mep_pseudo_cr64_write(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
#define ADD3_32_TARGET(i)
static int mep_use_struct_convention(struct type *type)
static mep_csr_register mep_csr_registers[]
static void mep_init_pseudoregister_maps(void)
static const CGEN_HW_ENTRY * find_hw_entry_by_type(CGEN_CPU_DESC desc, CGEN_HW_TYPE type)
static const CGEN_HW_ENTRY * me_module_register_set(CONFIG_ATTR me_module, const char *prefix, CGEN_HW_TYPE generic_type)
static CORE_ADDR mep_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int argc, struct value **argv, CORE_ADDR sp, function_call_return_method return_method, CORE_ADDR struct_addr)
#define IS_CR64_REGNUM(n)
static int mep_gdb_print_insn(bfd_vma pc, disassemble_info *info)
#define IS_CR32_REGNUM(n)
static void mep_pseudo_csr_write(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
static void mep_pseudo_cr32_write(struct gdbarch *gdbarch, struct regcache *regcache, int cookednum, const gdb_byte *buf)
static CGEN_KEYWORD * current_ccr_names(void)
static CORE_ADDR mep_frame_base(frame_info_ptr this_frame, void **this_prologue_cache)
static int me_module_cop_data_bus_width(CONFIG_ATTR me_module)
struct obj_section * find_pc_section(CORE_ADDR pc)
#define prefix(a, b, R, do)
int pv_is_register_k(pv_t a, int r, CORE_ADDR k)
pv_t pv_register(int reg, CORE_ADDR k)
int pv_is_identical(pv_t a, pv_t b)
pv_t pv_add_constant(pv_t v, CORE_ADDR k)
int pv_is_register(pv_t a, int r)
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
int register_size(struct gdbarch *gdbarch, int regnum)
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)
struct regcache * get_current_regcache(void)
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
const reggroup * reggroup_new(const char *name, enum reggroup_type type)
const reggroup *const save_reggroup
const reggroup *const all_reggroup
void reggroup_add(struct gdbarch *gdbarch, const reggroup *group)
const reggroup *const restore_reggroup
struct type * builtin_double
struct type * builtin_uint32
struct type * builtin_uint64
struct type * builtin_float
int reg_offset[MEP_NUM_REGS]
struct bfd_section * the_bfd_section
struct value::@195::@196 reg
int target_has_registers()
struct type * value_type(const struct value *value)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
LONGEST value_as_long(struct value *val)
value_ref_ptr release_value(struct value *val)