31#include "gdb/sim-frv.h"
32#include "opcodes/frv-desc.h"
105 CORE_ADDR *exec_addr)
113 if (interp_addr != NULL)
120 if (exec_addr != NULL)
150 *
sizeof (
const char *));
187 = xstrprintf (
"acc%d", r -
acc0_regnum).release ();
223 for (r = 0; r < num_gprs; ++r)
227 xsnprintf (buf,
sizeof (buf),
"gr%d", r);
242 for (r = 0; r < num_fprs; ++r)
246 xsnprintf (buf,
sizeof (buf),
"fr%d", r);
257 = xstrdup (
"loadmap_interp");
288static enum register_status
290 int reg, gdb_byte *buffer)
292 enum register_status
status;
312 memset (buffer, 0, 4);
316 buffer[0] = buf[byte_num];
320 gdb_assert_not_reached (
"invalid pseudo register number");
327 int reg,
const gdb_byte *buffer)
344 buf[byte_num] = ((bfd_byte *) buffer)[0];
352 static const int spr_map[] =
401 return SIM_FRV_PC_REGNUM;
407 if (spr_reg_offset < 0)
410 return SIM_FRV_SPR0_REGNUM + spr_reg_offset;
413 internal_error (_(
"Bad register number %d"), reg);
422static const int max_instrs_per_bundle = 8;
431frv_adjust_breakpoint_address (
struct gdbarch *
gdbarch, CORE_ADDR bpaddr)
433 int count = max_instrs_per_bundle;
440 while (count-- > 0 && addr >= func_start)
471 return ((4 <= reg && reg <= 7)
472 || (14 <= reg && reg <= 15)
473 || (32 <= reg && reg <= 47));
481 return ((16 <= reg && reg <= 31)
482 || (48 <= reg && reg <= 63));
490 return (8 <= reg && reg <= 13);
536 int lr_saved_on_stack = 0;
540 int lr_save_reg = -1;
544 int lr_sp_offset = 0;
550 int gr_sp_offset[64];
553 CORE_ADDR last_prologue_pc;
561 memset (gr_saved, 0,
sizeof (gr_saved));
563 last_prologue_pc = pc;
581 if (frame_pc < lim_pc)
631 if ((op & 0x01d80000) == 0x00180000
632 || (op & 0x01f80000) == 0x00300000
633 || (op & 0x01f80000) == 0x00100000
634 || (op & 0x01f80000) == 0x00700000)
646 else if ((op & 0x7ffc0fc0) == 0x04080100
647 || (op & 0x7ffc0000) == 0x04c80000)
658 else if ((op & 0x7fffffff) == 0x04881000)
662 last_prologue_pc = next_pc;
671 else if ((op & 0x7fffffc0) == 0x080d01c0)
673 int gr_j = op & 0x3f;
679 last_prologue_pc = next_pc;
696 else if ((op & 0x01ffffff) == 0x000c10c0
697 || (op & 0x01ffffff) == 0x000c1100)
699 int gr_k = ((op >> 25) & 0x3f);
700 int ope = ((op >> 6) & 0x3f);
713 for (i = 0; i < count; i++)
715 gr_saved[gr_k + i] = 1;
716 gr_sp_offset[gr_k + i] = 4 * i;
718 last_prologue_pc = next_pc;
728 else if ((op & 0x7ffff000) == 0x02401000)
734 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
737 last_prologue_pc = pc;
754 else if ((op & 0x7ffff000) == 0x04401000)
758 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
761 last_prologue_pc = pc;
776 else if ((op & 0x01fc0fff) == 0x00880000)
778 int gr_i = ((op >> 12) & 0x3f);
783 last_prologue_pc = next_pc;
798 else if ( (op & 0x01fff000) == 0x01442000
799 || (op & 0x01fff000) == 0x01402000)
801 int gr_k = ((op >> 25) & 0x3f);
806 last_prologue_pc = next_pc;
822 else if ((op & 0x01fff000) == 0x014c1000
823 || (op & 0x01fff000) == 0x01501000)
825 int gr_k = ((op >> 25) & 0x3f);
830 if ((op & 0x01fff000) == 0x014c1000)
840 int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
842 for (i = 0; i < count; i++)
844 gr_saved[gr_k + i] = 1;
845 gr_sp_offset[gr_k + i] = s + (4 * i);
847 last_prologue_pc = next_pc;
865 else if (((op & 0x01fc0fff) == 0x000c0080)
866 || ((op & 0x01fc0000) == 0x01480000))
868 int gr_k = ((op >> 25) & 0x3f);
869 int gr_i = ((op >> 12) & 0x3f);
874 if ((op & 0x01fc0fff) == 0x000c0080)
877 offset = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
891 last_prologue_pc = next_pc;
901 gr_sp_offset[gr_k] = offset;
903 gr_sp_offset[gr_k] = offset + fp_offset;
904 last_prologue_pc = next_pc;
908 else if (lr_save_reg != -1
909 && gr_k == lr_save_reg)
911 lr_saved_on_stack = 1;
913 lr_sp_offset = offset;
915 lr_sp_offset = offset + fp_offset;
916 last_prologue_pc = next_pc;
921 last_prologue_pc = next_pc;
926 if (this_frame && info)
941 for (i = 0; i < 64; i++)
943 info->saved_regs[i].set_addr (this_base - fp_offset
946 info->prev_sp = this_base - fp_offset + framesize;
947 info->base = this_base;
950 if (lr_saved_on_stack)
951 info->saved_regs[
lr_regnum].set_addr (this_base - fp_offset
961 info->saved_regs[
sp_regnum].set_value (info->prev_sp);
964 return last_prologue_pc;
971 CORE_ADDR func_addr, func_end, new_pc;
984 if (sal.
line != 0 && sal.
end < func_end)
993 if (new_pc <
pc + 20)
1010 CORE_ADDR orig_pc =
pc;
1037 if ((op & 0x7ffff000) == 0x1ec82000)
1055 if ((op & 0x01fc0000) == 0x003c0000)
1058 CORE_ADDR call_dest;
1061 displ = ((op & 0xfe000000) >> 7) | (op & 0x0003ffff);
1062 if ((displ & 0x00800000) != 0)
1063 displ |= ~((LONGEST) 0x00ffffff);
1065 call_dest = pc + 4 * displ;
1082 void **this_prologue_cache)
1087 if ((*this_prologue_cache))
1091 (*this_prologue_cache) = info;
1125 internal_error (_(
"Illegal return value length: %d"), len);
1132 return align_down (sp, 8);
1141 CORE_ADDR start_addr;
1146 || entry_point != start_addr)
1171 CORE_ADDR entry_point;
1172 CORE_ADDR got_address;
1186 int nargs,
struct value **args, CORE_ADDR sp,
1188 CORE_ADDR struct_addr)
1193 const gdb_byte *val;
1196 struct type *arg_type;
1206 printf(
"Push %d args at sp = %x, struct_return=%d (%x)\n",
1211 for (argnum = 0; argnum < nargs; ++argnum)
1214 stack_space -= (6 * 4);
1215 if (stack_space > 0)
1219 sp = align_down (sp, 8);
1229 for (argnum = 0; argnum < nargs; ++argnum)
1233 len = arg_type->
length ();
1234 typecode = arg_type->
code ();
1236 if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
1240 typecode = TYPE_CODE_PTR;
1246 && typecode == TYPE_CODE_PTR
1255 typecode = TYPE_CODE_PTR;
1266 int partial_len = (len < 4 ? len : 4);
1272 printf(
" Argnum %d data %x -> reg %d\n",
1273 argnum, (
int) regval, argreg);
1281 printf(
" Argnum %d data %x -> offset %d (%x)\n",
1282 argnum, *((
int *)val), stack_offset,
1283 (
int) (sp + stack_offset));
1286 stack_offset += align_up (partial_len, 4);
1313 const gdb_byte *valbuf)
1320 memset (val, 0,
sizeof (val));
1321 memcpy (val + (4 - len), valbuf, len);
1330 internal_error (_(
"Don't know how to return a %d-byte value."), len);
1336 gdb_byte *readbuf,
const gdb_byte *writebuf)
1339 || valtype->
code () == TYPE_CODE_UNION
1340 || valtype->
code () == TYPE_CODE_ARRAY;
1342 if (writebuf != NULL)
1348 if (readbuf != NULL)
1365 void **this_prologue_cache,
struct frame_id *this_id)
1385 base = info->prev_sp;
1393static struct value *
1395 void **this_prologue_cache,
int regnum)
1441 switch (
info.bfd_arch_info->mach)
1444 case bfd_mach_frvsimple:
1445 case bfd_mach_fr300:
1446 case bfd_mach_fr500:
1447 case bfd_mach_frvtomcat:
1448 case bfd_mach_fr550:
1453 case bfd_mach_fr400:
1454 case bfd_mach_fr450:
1465 if (
info.abfd && bfd_get_flavour (
info.abfd) == bfd_target_elf_flavour)
1466 elf_flags = elf_elfheader (
info.abfd)->e_flags;
1468 if (elf_flags & EF_FRV_FDPIC)
1471 if (elf_flags & EF_FRV_CPU_FR450)
1504 (
gdbarch, frv_adjust_breakpoint_address);
1521 switch (
info.bfd_arch_info->mach)
1524 case bfd_mach_frvsimple:
1525 case bfd_mach_fr300:
1526 case bfd_mach_fr500:
1527 case bfd_mach_frvtomcat:
1533 case bfd_mach_fr400:
1534 case bfd_mach_fr450:
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)
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)
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 * new_variant(void)
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)
const struct target_so_ops frv_so_ops
@ fdpic_loadmap_interp_regnum
@ fdpic_loadmap_exec_regnum
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, struct gdbarch_tdep_base *tdep)
function_call_return_method
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
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)
struct type * value_type(const struct value *value)
CORE_ADDR value_address(const struct value *value)
gdb::array_view< const gdb_byte > value_contents(struct value *value)
LONGEST value_as_long(struct value *val)