31#include "sim/sim-frv.h"
43#define GDB_CGEN_REMAP_PREFIX frv
45#include "opcodes/frv-desc.h"
103 return tdep->frv_abi;
111 CORE_ADDR *exec_addr)
119 if (interp_addr != NULL)
126 if (exec_addr != NULL)
149 var->num_hw_watchpoints = 0;
150 var->num_hw_breakpoints = 0;
156 *
sizeof (
const char *));
158 var->register_names[r] =
"";
192 var->register_names[r]
193 = xstrprintf (
"acc%d", r -
acc0_regnum).release ();
202 var->register_names[r]
229 for (r = 0; r < num_gprs; ++r)
233 xsnprintf (buf,
sizeof (buf),
"gr%d", r);
248 for (r = 0; r < num_fprs; ++r)
252 xsnprintf (buf,
sizeof (buf),
"fr%d", r);
263 = xstrdup (
"loadmap_interp");
294static enum register_status
296 int reg, gdb_byte *buffer)
298 enum register_status
status;
318 memset (buffer, 0, 4);
322 buffer[0] = buf[byte_num];
326 gdb_assert_not_reached (
"invalid pseudo register number");
333 int reg,
const gdb_byte *buffer)
350 buf[byte_num] = ((bfd_byte *) buffer)[0];
358 static const int spr_map[] =
407 return SIM_FRV_PC_REGNUM;
413 if (spr_reg_offset < 0)
416 return SIM_FRV_SPR0_REGNUM + spr_reg_offset;
419 internal_error (_(
"Bad register number %d"), reg);
428static const int max_instrs_per_bundle = 8;
437frv_adjust_breakpoint_address (
struct gdbarch *
gdbarch, CORE_ADDR bpaddr)
439 int count = max_instrs_per_bundle;
446 while (count-- > 0 && addr >= func_start)
477 return ((4 <= reg && reg <= 7)
478 || (14 <= reg && reg <= 15)
479 || (32 <= reg && reg <= 47));
487 return ((16 <= reg && reg <= 31)
488 || (48 <= reg && reg <= 63));
496 return (8 <= reg && reg <= 13);
542 int lr_saved_on_stack = 0;
546 int lr_save_reg = -1;
550 int lr_sp_offset = 0;
556 int gr_sp_offset[64];
559 CORE_ADDR last_prologue_pc;
567 memset (gr_saved, 0,
sizeof (gr_saved));
569 last_prologue_pc = pc;
587 if (frame_pc < lim_pc)
637 if ((op & 0x01d80000) == 0x00180000
638 || (op & 0x01f80000) == 0x00300000
639 || (op & 0x01f80000) == 0x00100000
640 || (op & 0x01f80000) == 0x00700000)
652 else if ((op & 0x7ffc0fc0) == 0x04080100
653 || (op & 0x7ffc0000) == 0x04c80000)
664 else if ((op & 0x7fffffff) == 0x04881000)
668 last_prologue_pc = next_pc;
677 else if ((op & 0x7fffffc0) == 0x080d01c0)
679 int gr_j = op & 0x3f;
685 last_prologue_pc = next_pc;
702 else if ((op & 0x01ffffff) == 0x000c10c0
703 || (op & 0x01ffffff) == 0x000c1100)
705 int gr_k = ((op >> 25) & 0x3f);
706 int ope = ((op >> 6) & 0x3f);
719 for (i = 0; i < count; i++)
721 gr_saved[gr_k + i] = 1;
722 gr_sp_offset[gr_k + i] = 4 * i;
724 last_prologue_pc = next_pc;
734 else if ((op & 0x7ffff000) == 0x02401000)
740 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
743 last_prologue_pc = pc;
760 else if ((op & 0x7ffff000) == 0x04401000)
764 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
767 last_prologue_pc = pc;
782 else if ((op & 0x01fc0fff) == 0x00880000)
784 int gr_i = ((op >> 12) & 0x3f);
789 last_prologue_pc = next_pc;
804 else if ( (op & 0x01fff000) == 0x01442000
805 || (op & 0x01fff000) == 0x01402000)
807 int gr_k = ((op >> 25) & 0x3f);
812 last_prologue_pc = next_pc;
828 else if ((op & 0x01fff000) == 0x014c1000
829 || (op & 0x01fff000) == 0x01501000)
831 int gr_k = ((op >> 25) & 0x3f);
836 if ((op & 0x01fff000) == 0x014c1000)
846 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
848 for (i = 0; i < count; i++)
850 gr_saved[gr_k + i] = 1;
851 gr_sp_offset[gr_k + i] = s + (4 * i);
853 last_prologue_pc = next_pc;
871 else if (((op & 0x01fc0fff) == 0x000c0080)
872 || ((op & 0x01fc0000) == 0x01480000))
874 int gr_k = ((op >> 25) & 0x3f);
875 int gr_i = ((op >> 12) & 0x3f);
880 if ((op & 0x01fc0fff) == 0x000c0080)
883 offset = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
897 last_prologue_pc = next_pc;
907 gr_sp_offset[gr_k] = offset;
909 gr_sp_offset[gr_k] = offset + fp_offset;
910 last_prologue_pc = next_pc;
914 else if (lr_save_reg != -1
915 && gr_k == lr_save_reg)
917 lr_saved_on_stack = 1;
919 lr_sp_offset = offset;
921 lr_sp_offset = offset + fp_offset;
922 last_prologue_pc = next_pc;
927 last_prologue_pc = next_pc;
932 if (this_frame && info)
947 for (i = 0; i < 64; i++)
949 info->saved_regs[i].set_addr (this_base - fp_offset
952 info->prev_sp = this_base - fp_offset + framesize;
953 info->base = this_base;
956 if (lr_saved_on_stack)
957 info->saved_regs[
lr_regnum].set_addr (this_base - fp_offset
967 info->saved_regs[
sp_regnum].set_value (info->prev_sp);
970 return last_prologue_pc;
977 CORE_ADDR func_addr, func_end, new_pc;
990 if (sal.
line != 0 && sal.
end < func_end)
999 if (new_pc <
pc + 20)
1016 CORE_ADDR orig_pc =
pc;
1043 if ((op & 0x7ffff000) == 0x1ec82000)
1061 if ((op & 0x01fc0000) == 0x003c0000)
1064 CORE_ADDR call_dest;
1067 displ = ((op & 0xfe000000) >> 7) | (op & 0x0003ffff);
1068 if ((displ & 0x00800000) != 0)
1069 displ |= ~((LONGEST) 0x00ffffff);
1071 call_dest = pc + 4 * displ;
1088 void **this_prologue_cache)
1093 if ((*this_prologue_cache))
1097 (*this_prologue_cache) = info;
1131 internal_error (_(
"Illegal return value length: %d"), len);
1138 return align_down (sp, 8);
1147 CORE_ADDR start_addr;
1152 || entry_point != start_addr)
1177 CORE_ADDR entry_point;
1178 CORE_ADDR got_address;
1192 int nargs,
struct value **args, CORE_ADDR sp,
1194 CORE_ADDR struct_addr)
1199 const gdb_byte *val;
1202 struct type *arg_type;
1212 printf(
"Push %d args at sp = %x, struct_return=%d (%x)\n",
1217 for (argnum = 0; argnum < nargs; ++argnum)
1218 stack_space += align_up (args[argnum]->
type ()->
length (), 4);
1220 stack_space -= (6 * 4);
1221 if (stack_space > 0)
1225 sp = align_down (sp, 8);
1235 for (argnum = 0; argnum < nargs; ++argnum)
1239 len = arg_type->
length ();
1240 typecode = arg_type->
code ();
1242 if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
1246 typecode = TYPE_CODE_PTR;
1252 && typecode == TYPE_CODE_PTR
1258 (arg->
contents ().data (), 4, byte_order);
1261 typecode = TYPE_CODE_PTR;
1272 int partial_len = (len < 4 ? len : 4);
1278 printf(
" Argnum %d data %x -> reg %d\n",
1279 argnum, (
int) regval, argreg);
1287 printf(
" Argnum %d data %x -> offset %d (%x)\n",
1288 argnum, *((
int *)val), stack_offset,
1289 (
int) (sp + stack_offset));
1292 stack_offset += align_up (partial_len, 4);
1319 const gdb_byte *valbuf)
1326 memset (val, 0,
sizeof (val));
1327 memcpy (val + (4 - len), valbuf, len);
1336 internal_error (_(
"Don't know how to return a %d-byte value."), len);
1342 gdb_byte *readbuf,
const gdb_byte *writebuf)
1345 || valtype->
code () == TYPE_CODE_UNION
1346 || valtype->
code () == TYPE_CODE_ARRAY;
1348 if (writebuf != NULL)
1354 if (readbuf != NULL)
1371 void **this_prologue_cache,
struct frame_id *this_id)
1391 base = info->prev_sp;
1399static struct value *
1401 void **this_prologue_cache,
int regnum)
1448 switch (
info.bfd_arch_info->mach)
1451 case bfd_mach_frvsimple:
1452 case bfd_mach_fr300:
1453 case bfd_mach_fr500:
1454 case bfd_mach_frvtomcat:
1455 case bfd_mach_fr550:
1460 case bfd_mach_fr400:
1461 case bfd_mach_fr450:
1472 if (
info.abfd && bfd_get_flavour (
info.abfd) == bfd_target_elf_flavour)
1473 elf_flags = elf_elfheader (
info.abfd)->e_flags;
1475 if (elf_flags & EF_FRV_FDPIC)
1478 if (elf_flags & EF_FRV_CPU_FR450)
1509 (
gdbarch, frv_adjust_breakpoint_address);
1526 switch (
info.bfd_arch_info->mach)
1529 case bfd_mach_frvsimple:
1530 case bfd_mach_fr300:
1531 case bfd_mach_fr500:
1532 case bfd_mach_frvtomcat:
1538 case bfd_mach_fr400:
1539 case bfd_mach_fr450:
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)
bool find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr, const struct block **block)
CORE_ADDR get_pc_function_start(CORE_ADDR pc)
enum register_status raw_read(int regnum, gdb_byte *buf)
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)
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
@ RETURN_VALUE_REGISTER_CONVENTION
@ RETURN_VALUE_STRUCT_CONVENTION
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)
enum unwind_stop_reason default_frame_unwind_stop_reason(frame_info_ptr this_frame, void **this_cache)
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)
#define FRAME_OBSTACK_ZALLOC(TYPE)
static const int frv_instr_size
static struct type * frv_register_type(struct gdbarch *gdbarch, int reg)
static const char * frv_register_name(struct gdbarch *gdbarch, int reg)
constexpr gdb_byte frv_break_insn[]
static void frv_store_return_value(struct type *type, struct regcache *regcache, const gdb_byte *valbuf)
static CORE_ADDR frv_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static CORE_ADDR frv_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 void set_variant_num_gprs(frv_gdbarch_tdep *var, int num_gprs)
int frv_fdpic_loadmap_addresses(struct gdbarch *gdbarch, CORE_ADDR *interp_addr, CORE_ADDR *exec_addr)
static void set_variant_num_fprs(frv_gdbarch_tdep *var, int num_fprs)
static const struct frame_base frv_frame_base
static CORE_ADDR frv_frame_base_address(frame_info_ptr this_frame, void **this_cache)
static CORE_ADDR find_func_descr(struct gdbarch *gdbarch, CORE_ADDR entry_point)
static struct gdbarch * frv_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
static enum return_value_convention frv_return_value(struct gdbarch *gdbarch, struct value *function, struct type *valtype, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
static void frv_extract_return_value(struct type *type, struct regcache *regcache, gdb_byte *valbuf)
static const struct frame_unwind frv_frame_unwind
static enum register_status frv_pseudo_register_read(struct gdbarch *gdbarch, readable_regcache *regcache, int reg, gdb_byte *buffer)
static int is_caller_saves_reg(int reg)
static int is_argument_reg(int reg)
static struct value * frv_frame_prev_register(frame_info_ptr this_frame, void **this_prologue_cache, int regnum)
static CORE_ADDR frv_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
void _initialize_frv_tdep()
static void frv_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int reg, const gdb_byte *buffer)
std::unique_ptr< frv_gdbarch_tdep > frv_gdbarch_tdep_up
static void set_variant_scratch_registers(frv_gdbarch_tdep *var)
static CORE_ADDR frv_convert_from_func_ptr_addr(struct gdbarch *gdbarch, CORE_ADDR addr, struct target_ops *targ)
static struct frv_unwind_cache * frv_frame_unwind_cache(frame_info_ptr this_frame, void **this_prologue_cache)
static frv_gdbarch_tdep_up new_variant()
static CORE_ADDR frv_analyze_prologue(struct gdbarch *gdbarch, CORE_ADDR pc, frame_info_ptr this_frame, struct frv_unwind_cache *info)
static void set_variant_abi_fdpic(frv_gdbarch_tdep *var)
static int is_callee_saves_reg(int reg)
static CORE_ADDR frv_skip_main_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
static void frv_frame_this_id(frame_info_ptr this_frame, void **this_prologue_cache, struct frame_id *this_id)
static int frv_register_sim_regno(struct gdbarch *gdbarch, int reg)
CORE_ADDR frv_fetch_objfile_link_map(struct objfile *objfile)
CORE_ADDR frv_fdpic_find_global_pointer(CORE_ADDR addr)
CORE_ADDR frv_fdpic_find_canonical_descriptor(CORE_ADDR entry_point)
@ fdpic_loadmap_interp_regnum
@ fdpic_loadmap_exec_regnum
const struct target_so_ops frv_so_ops
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
void set_gdbarch_convert_from_func_ptr_addr(struct gdbarch *gdbarch, gdbarch_convert_from_func_ptr_addr_ftype *convert_from_func_ptr_addr)
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)
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_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)
int gdbarch_num_regs(struct gdbarch *gdbarch)
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
void set_gdbarch_skip_main_prologue(struct gdbarch *gdbarch, gdbarch_skip_main_prologue_ftype *skip_main_prologue)
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_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
void set_gdbarch_adjust_breakpoint_address(struct gdbarch *gdbarch, gdbarch_adjust_breakpoint_address_ftype *adjust_breakpoint_address)
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_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)
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype *fetch_tls_load_module_address)
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype *pseudo_register_read)
void set_gdbarch_deprecated_fp_regnum(struct gdbarch *gdbarch, int deprecated_fp_regnum)
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)
void set_gdbarch_so_ops(struct gdbarch *gdbarch, const struct target_so_ops *so_ops)
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype *push_dummy_call)
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, gdbarch_tdep_up tdep)
function_call_return_method
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
CORE_ADDR find_function_addr(struct value *function, struct type **retval_type, struct type **function_type)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
struct bound_minimal_symbol lookup_minimal_symbol_by_pc(CORE_ADDR pc)
void gdbarch_init_osabi(struct gdbarch_info info, struct gdbarch *gdbarch)
enum register_status regcache_cooked_read_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)
void(* func)(remote_target *remote, char *)
@ SIM_REGNO_DOES_NOT_EXIST
CORE_ADDR value_address() const
struct minimal_symbol * minsym
struct type * builtin_int64
struct type * builtin_int32
struct type * builtin_float
const char ** register_names
trad_frame_saved_reg * saved_regs
const char * linkage_name() const
struct type * target_type() 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)
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
ULONGEST get_target_memory_unsigned(struct target_ops *ops, CORE_ADDR addr, int len, enum bfd_endian byte_order)
trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
struct value * trad_frame_get_prev_register(frame_info_ptr this_frame, trad_frame_saved_reg this_saved_regs[], int regnum)
struct value * value_allocate_space_in_inferior(int len)
LONGEST value_as_long(struct value *val)