#include "defs.h"
#include "gdb_string.h"
#include "inferior.h"
#include "gdbcore.h"
#include "arch-utils.h"
#include "regcache.h"
#include "frame.h"
#include "frame-unwind.h"
#include "frame-base.h"
#include "trad-frame.h"
#include "dis-asm.h"
#include "gdb_assert.h"
#include "sim-regno.h"
#include "gdb/sim-frv.h"
#include "opcodes/frv-desc.h"
#include "symtab.h"
#include "elf-bfd.h"
#include "elf/frv.h"
#include "osabi.h"
#include "infcall.h"
#include "frv-tdep.h"
extern void _initialize_frv_tdep (void);
static gdbarch_init_ftype frv_gdbarch_init;
static gdbarch_register_name_ftype frv_register_name;
static gdbarch_breakpoint_from_pc_ftype frv_breakpoint_from_pc;
static gdbarch_adjust_breakpoint_address_ftype frv_gdbarch_adjust_breakpoint_address;
static gdbarch_skip_prologue_ftype frv_skip_prologue;
struct frv_unwind_cache
{
CORE_ADDR prev_sp;
CORE_ADDR base;
struct trad_frame_saved_reg *saved_regs;
};
struct gdbarch_tdep
{
enum frv_abi frv_abi;
int num_gprs;
int num_fprs;
int num_hw_watchpoints;
int num_hw_breakpoints;
char **register_names;
};
#define CURRENT_VARIANT (gdbarch_tdep (current_gdbarch))
enum frv_abi
frv_abi (struct gdbarch *gdbarch)
{
return gdbarch_tdep (gdbarch)->frv_abi;
}
int
frv_fdpic_loadmap_addresses (struct gdbarch *gdbarch, CORE_ADDR *interp_addr,
CORE_ADDR *exec_addr)
{
if (frv_abi (gdbarch) != FRV_ABI_FDPIC)
return -1;
else
{
if (interp_addr != NULL)
{
ULONGEST val;
regcache_cooked_read_unsigned (current_regcache,
fdpic_loadmap_interp_regnum, &val);
*interp_addr = val;
}
if (exec_addr != NULL)
{
ULONGEST val;
regcache_cooked_read_unsigned (current_regcache,
fdpic_loadmap_exec_regnum, &val);
*exec_addr = val;
}
return 0;
}
}
static struct gdbarch_tdep *
new_variant (void)
{
struct gdbarch_tdep *var;
int r;
char buf[20];
var = xmalloc (sizeof (*var));
memset (var, 0, sizeof (*var));
var->frv_abi = FRV_ABI_EABI;
var->num_gprs = 64;
var->num_fprs = 64;
var->num_hw_watchpoints = 0;
var->num_hw_breakpoints = 0;
var->register_names
= (char **) xmalloc ((frv_num_regs + frv_num_pseudo_regs)
* sizeof (char *));
for (r = 0; r < frv_num_regs + frv_num_pseudo_regs; r++)
var->register_names[r] = "";
var->register_names[pc_regnum] = "pc";
var->register_names[lr_regnum] = "lr";
var->register_names[lcr_regnum] = "lcr";
var->register_names[psr_regnum] = "psr";
var->register_names[ccr_regnum] = "ccr";
var->register_names[cccr_regnum] = "cccr";
var->register_names[tbr_regnum] = "tbr";
var->register_names[brr_regnum] = "brr";
var->register_names[dbar0_regnum] = "dbar0";
var->register_names[dbar1_regnum] = "dbar1";
var->register_names[dbar2_regnum] = "dbar2";
var->register_names[dbar3_regnum] = "dbar3";
var->register_names[iacc0h_regnum] = "iacc0h";
var->register_names[iacc0l_regnum] = "iacc0l";
var->register_names[iacc0_regnum] = "iacc0";
var->register_names[fsr0_regnum] = "fsr0";
for (r = acc0_regnum; r <= acc7_regnum; r++)
{
char *buf;
buf = xstrprintf ("acc%d", r - acc0_regnum);
var->register_names[r] = buf;
}
for (r = accg0_regnum; r <= accg7_regnum; r++)
{
char *buf;
buf = xstrprintf ("accg%d", r - accg0_regnum);
var->register_names[r] = buf;
}
var->register_names[msr0_regnum] = "msr0";
var->register_names[msr1_regnum] = "msr1";
var->register_names[gner0_regnum] = "gner0";
var->register_names[gner1_regnum] = "gner1";
var->register_names[fner0_regnum] = "fner0";
var->register_names[fner1_regnum] = "fner1";
return var;
}
static void
set_variant_num_gprs (struct gdbarch_tdep *var, int num_gprs)
{
int r;
var->num_gprs = num_gprs;
for (r = 0; r < num_gprs; ++r)
{
char buf[20];
sprintf (buf, "gr%d", r);
var->register_names[first_gpr_regnum + r] = xstrdup (buf);
}
}
static void
set_variant_num_fprs (struct gdbarch_tdep *var, int num_fprs)
{
int r;
var->num_fprs = num_fprs;
for (r = 0; r < num_fprs; ++r)
{
char buf[20];
sprintf (buf, "fr%d", r);
var->register_names[first_fpr_regnum + r] = xstrdup (buf);
}
}
static void
set_variant_abi_fdpic (struct gdbarch_tdep *var)
{
var->frv_abi = FRV_ABI_FDPIC;
var->register_names[fdpic_loadmap_exec_regnum] = xstrdup ("loadmap_exec");
var->register_names[fdpic_loadmap_interp_regnum] = xstrdup ("loadmap_interp");
}
static void
set_variant_scratch_registers (struct gdbarch_tdep *var)
{
var->register_names[scr0_regnum] = xstrdup ("scr0");
var->register_names[scr1_regnum] = xstrdup ("scr1");
var->register_names[scr2_regnum] = xstrdup ("scr2");
var->register_names[scr3_regnum] = xstrdup ("scr3");
}
static const char *
frv_register_name (int reg)
{
if (reg < 0)
return "?toosmall?";
if (reg >= frv_num_regs + frv_num_pseudo_regs)
return "?toolarge?";
return CURRENT_VARIANT->register_names[reg];
}
static struct type *
frv_register_type (struct gdbarch *gdbarch, int reg)
{
if (reg >= first_fpr_regnum && reg <= last_fpr_regnum)
return builtin_type_float;
else if (reg == iacc0_regnum)
return builtin_type_int64;
else
return builtin_type_int32;
}
static void
frv_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
int reg, void *buffer)
{
if (reg == iacc0_regnum)
{
regcache_raw_read (regcache, iacc0h_regnum, buffer);
regcache_raw_read (regcache, iacc0l_regnum, (bfd_byte *) buffer + 4);
}
else if (accg0_regnum <= reg && reg <= accg7_regnum)
{
int raw_regnum = accg0123_regnum + (reg - accg0_regnum) / 4;
int byte_num = (reg - accg0_regnum) % 4;
bfd_byte buf[4];
regcache_raw_read (regcache, raw_regnum, buf);
memset (buffer, 0, 4);
((bfd_byte *) buffer)[0] = buf[byte_num];
}
}
static void
frv_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
int reg, const void *buffer)
{
if (reg == iacc0_regnum)
{
regcache_raw_write (regcache, iacc0h_regnum, buffer);
regcache_raw_write (regcache, iacc0l_regnum, (bfd_byte *) buffer + 4);
}
else if (accg0_regnum <= reg && reg <= accg7_regnum)
{
int raw_regnum = accg0123_regnum + (reg - accg0_regnum) / 4;
int byte_num = (reg - accg0_regnum) % 4;
char buf[4];
regcache_raw_read (regcache, raw_regnum, buf);
buf[byte_num] = ((bfd_byte *) buffer)[0];
regcache_raw_write (regcache, raw_regnum, buf);
}
}
static int
frv_register_sim_regno (int reg)
{
static const int spr_map[] =
{
H_SPR_PSR,
H_SPR_CCR,
H_SPR_CCCR,
-1,
-1,
-1,
H_SPR_TBR,
H_SPR_BRR,
H_SPR_DBAR0,
H_SPR_DBAR1,
H_SPR_DBAR2,
H_SPR_DBAR3,
H_SPR_SCR0,
H_SPR_SCR1,
H_SPR_SCR2,
H_SPR_SCR3,
H_SPR_LR,
H_SPR_LCR,
H_SPR_IACC0H,
H_SPR_IACC0L,
H_SPR_FSR0,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
H_SPR_MSR0,
H_SPR_MSR1,
H_SPR_GNER0,
H_SPR_GNER1,
H_SPR_FNER0,
H_SPR_FNER1,
};
gdb_assert (reg >= 0 && reg < NUM_REGS);
if (first_gpr_regnum <= reg && reg <= last_gpr_regnum)
return reg - first_gpr_regnum + SIM_FRV_GR0_REGNUM;
else if (first_fpr_regnum <= reg && reg <= last_fpr_regnum)
return reg - first_fpr_regnum + SIM_FRV_FR0_REGNUM;
else if (pc_regnum == reg)
return SIM_FRV_PC_REGNUM;
else if (reg >= first_spr_regnum
&& reg < first_spr_regnum + sizeof (spr_map) / sizeof (spr_map[0]))
{
int spr_reg_offset = spr_map[reg - first_spr_regnum];
if (spr_reg_offset < 0)
return SIM_REGNO_DOES_NOT_EXIST;
else
return SIM_FRV_SPR0_REGNUM + spr_reg_offset;
}
internal_error (__FILE__, __LINE__, _("Bad register number %d"), reg);
}
static const unsigned char *
frv_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenp)
{
static unsigned char breakpoint[] = {0xc0, 0x70, 0x00, 0x01};
*lenp = sizeof (breakpoint);
return breakpoint;
}
static const int max_instrs_per_bundle = 8;
static const int frv_instr_size = 4;
static CORE_ADDR
frv_gdbarch_adjust_breakpoint_address (struct gdbarch *gdbarch, CORE_ADDR bpaddr)
{
int count = max_instrs_per_bundle;
CORE_ADDR addr = bpaddr - frv_instr_size;
CORE_ADDR func_start = get_pc_function_start (bpaddr);
while (count-- > 0 && addr >= func_start)
{
char instr[frv_instr_size];
int status;
status = deprecated_read_memory_nobpt (addr, instr, sizeof instr);
if (status != 0)
break;
if (instr[0] & 0x80)
break;
addr -= frv_instr_size;
}
if (count > 0)
bpaddr = addr + frv_instr_size;
return bpaddr;
}
static int
is_caller_saves_reg (int reg)
{
return ((4 <= reg && reg <= 7)
|| (14 <= reg && reg <= 15)
|| (32 <= reg && reg <= 47));
}
static int
is_callee_saves_reg (int reg)
{
return ((16 <= reg && reg <= 31)
|| (48 <= reg && reg <= 63));
}
static int
is_argument_reg (int reg)
{
return (8 <= reg && reg <= 13);
}
static CORE_ADDR
frv_analyze_prologue (CORE_ADDR pc, struct frame_info *next_frame,
struct frv_unwind_cache *info)
{
int fp_set = 0;
int fp_offset = 0;
int framesize = 0;
int lr_saved_on_stack = 0;
int lr_save_reg = -1;
int lr_sp_offset = 0;
char gr_saved[64];
int gr_sp_offset[64];
CORE_ADDR last_prologue_pc;
CORE_ADDR next_pc;
CORE_ADDR lim_pc;
memset (gr_saved, 0, sizeof (gr_saved));
last_prologue_pc = pc;
lim_pc = skip_prologue_using_sal (pc);
if (lim_pc == 0)
lim_pc = pc + 400;
if (next_frame)
{
CORE_ADDR frame_pc = frame_pc_unwind (next_frame);
if (frame_pc < lim_pc)
lim_pc = frame_pc;
}
while (pc < lim_pc)
{
char buf[frv_instr_size];
LONGEST op;
if (target_read_memory (pc, buf, sizeof buf) != 0)
break;
op = extract_signed_integer (buf, sizeof buf);
next_pc = pc + 4;
if ((op & 0x01d80000) == 0x00180000
|| (op & 0x01f80000) == 0x00300000
|| (op & 0x01f80000) == 0x00100000
|| (op & 0x01f80000) == 0x00700000)
{
break;
}
else if ((op & 0x7ffc0fc0) == 0x04080100
|| (op & 0x7ffc0000) == 0x04c80000)
{
break;
}
else if ((op & 0x7fffffff) == 0x04881000)
{
fp_set = 1;
fp_offset = 0;
last_prologue_pc = next_pc;
}
else if ((op & 0x7fffffc0) == 0x080d01c0)
{
int gr_j = op & 0x3f;
if (is_caller_saves_reg (gr_j))
{
lr_save_reg = gr_j;
last_prologue_pc = next_pc;
}
}
else if ((op & 0x01ffffff) == 0x000c10c0
|| (op & 0x01ffffff) == 0x000c1100)
{
int gr_k = ((op >> 25) & 0x3f);
int ope = ((op >> 6) & 0x3f);
int count;
int i;
if (ope == 0x03)
count = 2;
else
count = 4;
if (is_callee_saves_reg (gr_k))
{
for (i = 0; i < count; i++)
{
gr_saved[gr_k + i] = 1;
gr_sp_offset[gr_k + i] = 4 * i;
}
last_prologue_pc = next_pc;
}
}
else if ((op & 0x7ffff000) == 0x02401000)
{
if (framesize == 0)
{
int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
framesize -= s;
last_prologue_pc = pc;
}
else
{
break;
}
}
else if ((op & 0x7ffff000) == 0x04401000)
{
int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
fp_set = 1;
fp_offset = s;
last_prologue_pc = pc;
}
else if ((op & 0x01fc0fff) == 0x00880000)
{
int gr_i = ((op >> 12) & 0x3f);
if (is_argument_reg (gr_i))
last_prologue_pc = next_pc;
}
else if ( (op & 0x01fff000) == 0x01442000
|| (op & 0x01fff000) == 0x01402000)
{
int gr_k = ((op >> 25) & 0x3f);
if (is_argument_reg (gr_k))
last_prologue_pc = next_pc;
}
else if ((op & 0x01fff000) == 0x014c1000
|| (op & 0x01fff000) == 0x01501000)
{
int gr_k = ((op >> 25) & 0x3f);
int count;
int i;
if ((op & 0x01fff000) == 0x014c1000)
count = 2;
else
count = 4;
if (is_callee_saves_reg (gr_k))
{
int s = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
for (i = 0; i < count; i++)
{
gr_saved[gr_k + i] = 1;
gr_sp_offset[gr_k + i] = s + (4 * i);
}
last_prologue_pc = next_pc;
}
}
else if (((op & 0x01fc0fff) == 0x000c0080)
|| ((op & 0x01fc0000) == 0x01480000))
{
int gr_k = ((op >> 25) & 0x3f);
int gr_i = ((op >> 12) & 0x3f);
int offset;
if ((op & 0x01fc0fff) == 0x000c0080)
offset = 0;
else
offset = (((op & 0xfff) - 0x800) & 0xfff) - 0x800;
if (gr_i != sp_regnum && gr_i != fp_regnum)
{
}
else if (gr_k == fp_regnum && gr_i == sp_regnum)
{
gr_saved[fp_regnum] = 1;
gr_sp_offset[fp_regnum] = offset;
last_prologue_pc = next_pc;
}
else if (gr_i == sp_regnum
&& is_callee_saves_reg (gr_k))
{
gr_saved[gr_k] = 1;
if (gr_i == sp_regnum)
gr_sp_offset[gr_k] = offset;
else
gr_sp_offset[gr_k] = offset + fp_offset;
last_prologue_pc = next_pc;
}
else if (lr_save_reg != -1
&& gr_k == lr_save_reg)
{
lr_saved_on_stack = 1;
if (gr_i == sp_regnum)
lr_sp_offset = offset;
else
lr_sp_offset = offset + fp_offset;
last_prologue_pc = next_pc;
}
else if (is_argument_reg (gr_k))
last_prologue_pc = next_pc;
}
pc = next_pc;
}
if (next_frame && info)
{
int i;
ULONGEST this_base;
if (fp_set)
frame_unwind_unsigned_register (next_frame, fp_regnum, &this_base);
else
frame_unwind_unsigned_register (next_frame, sp_regnum, &this_base);
for (i = 0; i < 64; i++)
if (gr_saved[i])
info->saved_regs[i].addr = this_base - fp_offset + gr_sp_offset[i];
info->prev_sp = this_base - fp_offset + framesize;
info->base = this_base;
if (lr_saved_on_stack)
info->saved_regs[lr_regnum].addr = this_base - fp_offset + lr_sp_offset;
info->saved_regs[pc_regnum] = info->saved_regs[lr_regnum];
trad_frame_set_value (info->saved_regs, sp_regnum, info->prev_sp);
}
return last_prologue_pc;
}
static CORE_ADDR
frv_skip_prologue (CORE_ADDR pc)
{
CORE_ADDR func_addr, func_end, new_pc;
new_pc = pc;
if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
{
struct symtab_and_line sal;
sal = find_pc_line (func_addr, 0);
if (sal.line != 0 && sal.end < func_end)
{
new_pc = sal.end;
}
}
if (new_pc < pc + 20)
new_pc = frv_analyze_prologue (pc, 0, 0);
return new_pc;
}
static struct frv_unwind_cache *
frv_frame_unwind_cache (struct frame_info *next_frame,
void **this_prologue_cache)
{
struct gdbarch *gdbarch = get_frame_arch (next_frame);
CORE_ADDR pc;
ULONGEST this_base;
struct frv_unwind_cache *info;
if ((*this_prologue_cache))
return (*this_prologue_cache);
info = FRAME_OBSTACK_ZALLOC (struct frv_unwind_cache);
(*this_prologue_cache) = info;
info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
frv_analyze_prologue (frame_func_unwind (next_frame), next_frame, info);
return info;
}
static void
frv_extract_return_value (struct type *type, struct regcache *regcache,
void *valbuf)
{
int len = TYPE_LENGTH (type);
if (len <= 4)
{
ULONGEST gpr8_val;
regcache_cooked_read_unsigned (regcache, 8, &gpr8_val);
store_unsigned_integer (valbuf, len, gpr8_val);
}
else if (len == 8)
{
ULONGEST regval;
regcache_cooked_read_unsigned (regcache, 8, ®val);
store_unsigned_integer (valbuf, 4, regval);
regcache_cooked_read_unsigned (regcache, 9, ®val);
store_unsigned_integer ((bfd_byte *) valbuf + 4, 4, regval);
}
else
internal_error (__FILE__, __LINE__, _("Illegal return value length: %d"), len);
}
static CORE_ADDR
frv_extract_struct_value_address (struct regcache *regcache)
{
ULONGEST addr;
regcache_cooked_read_unsigned (regcache, struct_return_regnum, &addr);
return addr;
}
static void
frv_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
write_register (struct_return_regnum, addr);
}
static CORE_ADDR
frv_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
{
return align_down (sp, 8);
}
static CORE_ADDR
find_func_descr (struct gdbarch *gdbarch, CORE_ADDR entry_point)
{
CORE_ADDR descr;
char valbuf[4];
CORE_ADDR start_addr;
if (!find_pc_partial_function (entry_point, NULL, &start_addr, NULL)
|| entry_point != start_addr)
return entry_point;
descr = frv_fdpic_find_canonical_descriptor (entry_point);
if (descr != 0)
return descr;
descr = value_as_long (value_allocate_space_in_inferior (8));
store_unsigned_integer (valbuf, 4, entry_point);
write_memory (descr, valbuf, 4);
store_unsigned_integer (valbuf, 4,
frv_fdpic_find_global_pointer (entry_point));
write_memory (descr + 4, valbuf, 4);
return descr;
}
static CORE_ADDR
frv_convert_from_func_ptr_addr (struct gdbarch *gdbarch, CORE_ADDR addr,
struct target_ops *targ)
{
CORE_ADDR entry_point;
CORE_ADDR got_address;
entry_point = get_target_memory_unsigned (targ, addr, 4);
got_address = get_target_memory_unsigned (targ, addr + 4, 4);
if (got_address == frv_fdpic_find_global_pointer (entry_point))
return entry_point;
else
return addr;
}
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,
int struct_return, CORE_ADDR struct_addr)
{
int argreg;
int argnum;
char *val;
char valbuf[4];
struct value *arg;
struct type *arg_type;
int len;
enum type_code typecode;
CORE_ADDR regval;
int stack_space;
int stack_offset;
enum frv_abi abi = frv_abi (gdbarch);
CORE_ADDR func_addr = find_function_addr (function, NULL);
#if 0
printf("Push %d args at sp = %x, struct_return=%d (%x)\n",
nargs, (int) sp, struct_return, struct_addr);
#endif
stack_space = 0;
for (argnum = 0; argnum < nargs; ++argnum)
stack_space += align_up (TYPE_LENGTH (value_type (args[argnum])), 4);
stack_space -= (6 * 4);
if (stack_space > 0)
sp -= stack_space;
sp = align_down (sp, 8);
stack_offset = 0;
argreg = 8;
if (struct_return)
regcache_cooked_write_unsigned (regcache, struct_return_regnum,
struct_addr);
for (argnum = 0; argnum < nargs; ++argnum)
{
arg = args[argnum];
arg_type = check_typedef (value_type (arg));
len = TYPE_LENGTH (arg_type);
typecode = TYPE_CODE (arg_type);
if (typecode == TYPE_CODE_STRUCT || typecode == TYPE_CODE_UNION)
{
store_unsigned_integer (valbuf, 4, VALUE_ADDRESS (arg));
typecode = TYPE_CODE_PTR;
len = 4;
val = valbuf;
}
else if (abi == FRV_ABI_FDPIC
&& len == 4
&& typecode == TYPE_CODE_PTR
&& TYPE_CODE (TYPE_TARGET_TYPE (arg_type)) == TYPE_CODE_FUNC)
{
store_unsigned_integer
(valbuf, 4,
find_func_descr (gdbarch,
extract_unsigned_integer (value_contents (arg),
4)));
typecode = TYPE_CODE_PTR;
len = 4;
val = valbuf;
}
else
{
val = (char *) value_contents (arg);
}
while (len > 0)
{
int partial_len = (len < 4 ? len : 4);
if (argreg < 14)
{
regval = extract_unsigned_integer (val, partial_len);
#if 0
printf(" Argnum %d data %x -> reg %d\n",
argnum, (int) regval, argreg);
#endif
regcache_cooked_write_unsigned (regcache, argreg, regval);
++argreg;
}
else
{
#if 0
printf(" Argnum %d data %x -> offset %d (%x)\n",
argnum, *((int *)val), stack_offset, (int) (sp + stack_offset));
#endif
write_memory (sp + stack_offset, val, partial_len);
stack_offset += align_up (partial_len, 4);
}
len -= partial_len;
val += partial_len;
}
}
regcache_cooked_write_unsigned (regcache, lr_regnum, bp_addr);
if (abi == FRV_ABI_FDPIC)
{
regcache_cooked_write_unsigned
(regcache, first_gpr_regnum + 15,
frv_fdpic_find_global_pointer (func_addr));
}
regcache_cooked_write_unsigned (regcache, sp_regnum, sp);
return sp;
}
static void
frv_store_return_value (struct type *type, struct regcache *regcache,
const void *valbuf)
{
int len = TYPE_LENGTH (type);
if (len <= 4)
{
bfd_byte val[4];
memset (val, 0, sizeof (val));
memcpy (val + (4 - len), valbuf, len);
regcache_cooked_write (regcache, 8, val);
}
else if (len == 8)
{
regcache_cooked_write (regcache, 8, valbuf);
regcache_cooked_write (regcache, 9, (bfd_byte *) valbuf + 4);
}
else
internal_error (__FILE__, __LINE__,
_("Don't know how to return a %d-byte value."), len);
}
int
frv_check_watch_resources (int type, int cnt, int ot)
{
struct gdbarch_tdep *var = CURRENT_VARIANT;
if (strcmp (target_shortname, "sim") == 0)
return 0;
if (type == bp_hardware_breakpoint)
{
if (var->num_hw_breakpoints == 0)
return 0;
else if (cnt <= var->num_hw_breakpoints)
return 1;
}
else
{
if (var->num_hw_watchpoints == 0)
return 0;
else if (ot)
return -1;
else if (cnt <= var->num_hw_watchpoints)
return 1;
}
return -1;
}
int
frv_stopped_data_address (CORE_ADDR *addr_p)
{
CORE_ADDR brr, dbar0, dbar1, dbar2, dbar3;
brr = read_register (brr_regnum);
dbar0 = read_register (dbar0_regnum);
dbar1 = read_register (dbar1_regnum);
dbar2 = read_register (dbar2_regnum);
dbar3 = read_register (dbar3_regnum);
if (brr & (1<<11))
*addr_p = dbar0;
else if (brr & (1<<10))
*addr_p = dbar1;
else if (brr & (1<<9))
*addr_p = dbar2;
else if (brr & (1<<8))
*addr_p = dbar3;
else
return 0;
return 1;
}
int
frv_have_stopped_data_address (void)
{
CORE_ADDR addr = 0;
return frv_stopped_data_address (&addr);
}
static CORE_ADDR
frv_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
return frame_unwind_register_unsigned (next_frame, pc_regnum);
}
static void
frv_frame_this_id (struct frame_info *next_frame,
void **this_prologue_cache, struct frame_id *this_id)
{
struct frv_unwind_cache *info
= frv_frame_unwind_cache (next_frame, this_prologue_cache);
CORE_ADDR base;
CORE_ADDR func;
struct minimal_symbol *msym_stack;
struct frame_id id;
func = frame_func_unwind (next_frame);
msym_stack = lookup_minimal_symbol ("_stack", NULL, NULL);
if (msym_stack && info->base == SYMBOL_VALUE_ADDRESS (msym_stack))
return;
base = info->prev_sp;
if (base == 0)
return;
id = frame_id_build (base, func);
(*this_id) = id;
}
static void
frv_frame_prev_register (struct frame_info *next_frame,
void **this_prologue_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
int *realnump, void *bufferp)
{
struct frv_unwind_cache *info
= frv_frame_unwind_cache (next_frame, this_prologue_cache);
trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
optimizedp, lvalp, addrp, realnump, bufferp);
}
static const struct frame_unwind frv_frame_unwind = {
NORMAL_FRAME,
frv_frame_this_id,
frv_frame_prev_register
};
static const struct frame_unwind *
frv_frame_sniffer (struct frame_info *next_frame)
{
return &frv_frame_unwind;
}
static CORE_ADDR
frv_frame_base_address (struct frame_info *next_frame, void **this_cache)
{
struct frv_unwind_cache *info
= frv_frame_unwind_cache (next_frame, this_cache);
return info->base;
}
static const struct frame_base frv_frame_base = {
&frv_frame_unwind,
frv_frame_base_address,
frv_frame_base_address,
frv_frame_base_address
};
static CORE_ADDR
frv_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
return frame_unwind_register_unsigned (next_frame, sp_regnum);
}
static struct frame_id
frv_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
{
return frame_id_build (frv_unwind_sp (gdbarch, next_frame),
frame_pc_unwind (next_frame));
}
static struct gdbarch *
frv_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
struct gdbarch_tdep *var;
int elf_flags = 0;
arches = gdbarch_list_lookup_by_info (arches, &info);
if (arches)
return arches->gdbarch;
var = new_variant ();
switch (info.bfd_arch_info->mach)
{
case bfd_mach_frv:
case bfd_mach_frvsimple:
case bfd_mach_fr500:
case bfd_mach_frvtomcat:
case bfd_mach_fr550:
set_variant_num_gprs (var, 64);
set_variant_num_fprs (var, 64);
break;
case bfd_mach_fr400:
case bfd_mach_fr450:
set_variant_num_gprs (var, 32);
set_variant_num_fprs (var, 32);
break;
default:
return 0;
}
if (info.abfd && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
elf_flags = elf_elfheader (info.abfd)->e_flags;
if (elf_flags & EF_FRV_FDPIC)
set_variant_abi_fdpic (var);
if (elf_flags & EF_FRV_CPU_FR450)
set_variant_scratch_registers (var);
gdbarch = gdbarch_alloc (&info, var);
set_gdbarch_short_bit (gdbarch, 16);
set_gdbarch_int_bit (gdbarch, 32);
set_gdbarch_long_bit (gdbarch, 32);
set_gdbarch_long_long_bit (gdbarch, 64);
set_gdbarch_float_bit (gdbarch, 32);
set_gdbarch_double_bit (gdbarch, 64);
set_gdbarch_long_double_bit (gdbarch, 64);
set_gdbarch_ptr_bit (gdbarch, 32);
set_gdbarch_num_regs (gdbarch, frv_num_regs);
set_gdbarch_num_pseudo_regs (gdbarch, frv_num_pseudo_regs);
set_gdbarch_sp_regnum (gdbarch, sp_regnum);
set_gdbarch_deprecated_fp_regnum (gdbarch, fp_regnum);
set_gdbarch_pc_regnum (gdbarch, pc_regnum);
set_gdbarch_register_name (gdbarch, frv_register_name);
set_gdbarch_register_type (gdbarch, frv_register_type);
set_gdbarch_register_sim_regno (gdbarch, frv_register_sim_regno);
set_gdbarch_pseudo_register_read (gdbarch, frv_pseudo_register_read);
set_gdbarch_pseudo_register_write (gdbarch, frv_pseudo_register_write);
set_gdbarch_skip_prologue (gdbarch, frv_skip_prologue);
set_gdbarch_breakpoint_from_pc (gdbarch, frv_breakpoint_from_pc);
set_gdbarch_adjust_breakpoint_address (gdbarch, frv_gdbarch_adjust_breakpoint_address);
set_gdbarch_deprecated_use_struct_convention (gdbarch, always_use_struct_convention);
set_gdbarch_extract_return_value (gdbarch, frv_extract_return_value);
set_gdbarch_deprecated_store_struct_return (gdbarch, frv_store_struct_return);
set_gdbarch_store_return_value (gdbarch, frv_store_return_value);
set_gdbarch_deprecated_extract_struct_value_address (gdbarch, frv_extract_struct_value_address);
set_gdbarch_unwind_pc (gdbarch, frv_unwind_pc);
set_gdbarch_unwind_sp (gdbarch, frv_unwind_sp);
set_gdbarch_frame_align (gdbarch, frv_frame_align);
frame_base_set_default (gdbarch, &frv_frame_base);
set_gdbarch_push_dummy_call (gdbarch, frv_push_dummy_call);
set_gdbarch_unwind_dummy_id (gdbarch, frv_unwind_dummy_id);
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
set_gdbarch_remote_translate_xfer_address
(gdbarch, generic_remote_translate_xfer_address);
switch (info.bfd_arch_info->mach)
{
case bfd_mach_frv:
case bfd_mach_frvsimple:
case bfd_mach_fr500:
case bfd_mach_frvtomcat:
var->num_hw_watchpoints = 4;
var->num_hw_breakpoints = 4;
break;
case bfd_mach_fr400:
case bfd_mach_fr450:
var->num_hw_watchpoints = 2;
var->num_hw_breakpoints = 4;
break;
default:
var->num_hw_watchpoints = 0;
var->num_hw_breakpoints = 0;
break;
}
set_gdbarch_print_insn (gdbarch, print_insn_frv);
if (frv_abi (gdbarch) == FRV_ABI_FDPIC)
set_gdbarch_convert_from_func_ptr_addr (gdbarch,
frv_convert_from_func_ptr_addr);
gdbarch_init_osabi (info, gdbarch);
frame_unwind_append_sniffer (gdbarch, frv_frame_sniffer);
set_gdbarch_fetch_tls_load_module_address (gdbarch,
frv_fetch_objfile_link_map);
return gdbarch;
}
void
_initialize_frv_tdep (void)
{
register_gdbarch_init (bfd_arch_frv, frv_gdbarch_init);
}