#include "gdbcore.h"
#include "symfile.h"
-char *mn10300_generic_register_names[] = REGISTER_NAMES;
-
-/* start-sanitize-am33 */
-char *am33_register_names [] =
+static char *mn10300_generic_register_names[] =
{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
- "sp", "pc", "mdr", "psw", "lir", "lar", "",
- "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
- "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""};
-int am33_mode;
-/* end-sanitize-am33 */
+ "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "fp" };
+
+char **mn10300_register_names = mn10300_generic_register_names;
static CORE_ADDR mn10300_analyze_prologue PARAMS ((struct frame_info *fi,
CORE_ADDR pc));
+/* Additional info used by the frame */
+
+struct frame_extra_info
+{
+ int status;
+ int stack_size;
+};
+
+static struct frame_info *analyze_dummy_frame PARAMS ((CORE_ADDR, CORE_ADDR));
+static struct frame_info *
+analyze_dummy_frame (pc, frame)
+ CORE_ADDR pc;
+ CORE_ADDR frame;
+{
+ static struct frame_info *dummy = NULL;
+ if (dummy == NULL)
+ {
+ dummy = xmalloc (sizeof (struct frame_info));
+ dummy->saved_regs = xmalloc (SIZEOF_FRAME_SAVED_REGS);
+ dummy->extra_info = xmalloc (sizeof (struct frame_extra_info));
+ }
+ dummy->next = NULL;
+ dummy->prev = NULL;
+ dummy->pc = pc;
+ dummy->frame = frame;
+ dummy->extra_info->status = 0;
+ dummy->extra_info->stack_size = 0;
+ memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
+ mn10300_analyze_prologue (dummy, 0);
+ return dummy;
+}
+
/* Values for frame_info.status */
#define MY_FRAME_IN_SP 0x1
#define MY_FRAME_IN_FP 0x2
#define NO_MORE_FRAMES 0x4
-
+
/* Should call_function allocate stack space for a struct return? */
int
return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 8);
}
+/* The breakpoint instruction must be the same size as the smallest
+ instruction in the instruction set.
+
+ The Matsushita mn10x00 processors have single byte instructions
+ so we need a single byte breakpoint. Matsushita hasn't defined
+ one, so we defined it ourselves. */
+
+unsigned char *
+mn10300_breakpoint_from_pc (bp_addr, bp_size)
+ CORE_ADDR *bp_addr;
+ int *bp_size;
+{
+ static char breakpoint[] = {0xff};
+ *bp_size = 1;
+ return breakpoint;
+}
+
/* Fix fi->frame if it's bogus at this point. This is a helper
function for mn10300_analyze_prologue. */
{
if (fi && fi->next == NULL)
{
- if (fi->status & MY_FRAME_IN_SP)
+ if (fi->extra_info->status & MY_FRAME_IN_SP)
fi->frame = read_sp () - stack_size;
- else if (fi->status & MY_FRAME_IN_FP)
+ else if (fi->extra_info->status & MY_FRAME_IN_FP)
fi->frame = read_register (A3_REGNUM);
}
}
if (movm_args & 0x10)
{
- fi->fsr.regs[A3_REGNUM] = fi->frame + offset;
+ fi->saved_regs[A3_REGNUM] = fi->frame + offset;
offset += 4;
}
if (movm_args & 0x20)
{
- fi->fsr.regs[A2_REGNUM] = fi->frame + offset;
+ fi->saved_regs[A2_REGNUM] = fi->frame + offset;
offset += 4;
}
if (movm_args & 0x40)
{
- fi->fsr.regs[D3_REGNUM] = fi->frame + offset;
+ fi->saved_regs[D3_REGNUM] = fi->frame + offset;
offset += 4;
}
if (movm_args & 0x80)
{
- fi->fsr.regs[D2_REGNUM] = fi->frame + offset;
+ fi->saved_regs[D2_REGNUM] = fi->frame + offset;
offset += 4;
}
- /* start-sanitize-am33 */
- if (am33_mode && movm_args & 0x02)
- {
- fi->fsr.regs[E0_REGNUM+5] = fi->frame + offset;
- fi->fsr.regs[E0_REGNUM+4] = fi->frame + offset + 4;
- fi->fsr.regs[E0_REGNUM+3] = fi->frame + offset + 8;
- fi->fsr.regs[E0_REGNUM+2] = fi->frame + offset + 12;
- }
- /* end-sanitize-am33 */
}
if (strcmp (name, "start") == 0)
{
if (fi != NULL)
- fi->status = NO_MORE_FRAMES;
+ fi->extra_info->status = NO_MORE_FRAMES;
return pc;
}
/* At the start of a function our frame is in the stack pointer. */
if (fi)
- fi->status = MY_FRAME_IN_SP;
+ fi->extra_info->status = MY_FRAME_IN_SP;
/* Get the next two bytes into buf, we need two because rets is a two
byte insn and the first isn't enough to uniquely identify it. */
if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
{
if (fi)
- fi->status = NO_MORE_FRAMES;
+ fi->extra_info->status = NO_MORE_FRAMES;
return addr;
}
/* The frame pointer is now valid. */
if (fi)
{
- fi->status |= MY_FRAME_IN_FP;
- fi->status &= ~MY_FRAME_IN_SP;
+ fi->extra_info->status |= MY_FRAME_IN_FP;
+ fi->extra_info->status &= ~MY_FRAME_IN_SP;
}
/* Quit now if we're beyond the stop point. */
/* Note the size of the stack in the frame info structure. */
stack_size = extract_signed_integer (buf, imm_size);
if (fi)
- fi->stack_size = stack_size;
+ fi->extra_info->stack_size = stack_size;
/* We just consumed 2 + imm_size bytes. */
addr += 2 + imm_size;
mn10300_frame_chain (fi)
struct frame_info *fi;
{
- struct frame_info dummy_frame;
-
+ struct frame_info *dummy;
/* Walk through the prologue to determine the stack size,
location of saved registers, end of the prologue, etc. */
- if (fi->status == 0)
+ if (fi->extra_info->status == 0)
mn10300_analyze_prologue (fi, (CORE_ADDR)0);
/* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
- if (fi->status & NO_MORE_FRAMES)
+ if (fi->extra_info->status & NO_MORE_FRAMES)
return 0;
/* Now that we've analyzed our prologue, determine the frame
frame base is fi->frame + -caller's stack size. */
/* The easiest way to get that info is to analyze our caller's frame.
-
So we set up a dummy frame and call mn10300_analyze_prologue to
find stuff for us. */
- dummy_frame.pc = FRAME_SAVED_PC (fi);
- dummy_frame.frame = fi->frame;
- memset (dummy_frame.fsr.regs, '\000', sizeof dummy_frame.fsr.regs);
- dummy_frame.status = 0;
- dummy_frame.stack_size = 0;
- mn10300_analyze_prologue (&dummy_frame, 0);
-
- if (dummy_frame.status & MY_FRAME_IN_FP)
+ dummy = analyze_dummy_frame (FRAME_SAVED_PC (fi), fi->frame);
+
+ if (dummy->extra_info->status & MY_FRAME_IN_FP)
{
/* Our caller has a frame pointer. So find the frame in $a3 or
in the stack. */
- if (fi->fsr.regs[A3_REGNUM])
- return (read_memory_integer (fi->fsr.regs[A3_REGNUM], REGISTER_SIZE));
+ if (fi->saved_regs[A3_REGNUM])
+ return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
else
return read_register (A3_REGNUM);
}
{
int adjust = 0;
- adjust += (fi->fsr.regs[D2_REGNUM] ? 4 : 0);
- adjust += (fi->fsr.regs[D3_REGNUM] ? 4 : 0);
- adjust += (fi->fsr.regs[A2_REGNUM] ? 4 : 0);
- adjust += (fi->fsr.regs[A3_REGNUM] ? 4 : 0);
- /* start-sanitize-am33 */
- if (am33_mode)
- {
- adjust += (fi->fsr.regs[E0_REGNUM+5] ? 4 : 0);
- adjust += (fi->fsr.regs[E0_REGNUM+4] ? 4 : 0);
- adjust += (fi->fsr.regs[E0_REGNUM+3] ? 4 : 0);
- adjust += (fi->fsr.regs[E0_REGNUM+2] ? 4 : 0);
- }
- /* end-sanitize-am33 */
+ adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
+ adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
+ adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
+ adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
/* Our caller does not have a frame pointer. So his frame starts
at the base of our frame (fi->frame) + register save space
+ <his size>. */
- return fi->frame + adjust + -dummy_frame.stack_size;
+ return fi->frame + adjust + -dummy->extra_info->stack_size;
}
}
/* Restore any saved registers. */
for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (frame->fsr.regs[regnum] != 0)
+ if (frame->saved_regs[regnum] != 0)
{
ULONGEST value;
- value = read_memory_unsigned_integer (frame->fsr.regs[regnum],
+ value = read_memory_unsigned_integer (frame->saved_regs[regnum],
REGISTER_RAW_SIZE (regnum));
write_register (regnum, value);
}
{
int adjust = 0;
- adjust += (fi->fsr.regs[D2_REGNUM] ? 4 : 0);
- adjust += (fi->fsr.regs[D3_REGNUM] ? 4 : 0);
- adjust += (fi->fsr.regs[A2_REGNUM] ? 4 : 0);
- adjust += (fi->fsr.regs[A3_REGNUM] ? 4 : 0);
- /* start-sanitize-am33 */
- if (am33_mode)
- {
- adjust += (fi->fsr.regs[E0_REGNUM+5] ? 4 : 0);
- adjust += (fi->fsr.regs[E0_REGNUM+4] ? 4 : 0);
- adjust += (fi->fsr.regs[E0_REGNUM+3] ? 4 : 0);
- adjust += (fi->fsr.regs[E0_REGNUM+2] ? 4 : 0);
- }
- /* end-sanitize-am33 */
+ adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
+ adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
+ adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
+ adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
}
frame, regnum, lval);
}
-/* Function: init_extra_frame_info
+/* Function: mn10300_init_extra_frame_info
Setup the frame's frame pointer, pc, and frame addresses for saved
registers. Most of the work is done in mn10300_analyze_prologue().
if (fi->next)
fi->pc = FRAME_SAVED_PC (fi->next);
- memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
- fi->status = 0;
- fi->stack_size = 0;
+ frame_saved_regs_zalloc (fi);
+ fi->extra_info = (struct frame_extra_info *)
+ frame_obstack_alloc (sizeof (struct frame_extra_info));
+
+ fi->extra_info->status = 0;
+ fi->extra_info->stack_size = 0;
mn10300_analyze_prologue (fi, 0);
}
+/* Function: mn10300_virtual_frame_pointer
+ Return the register that the function uses for a frame pointer,
+ plus any necessary offset to be applied to the register before
+ any frame pointer offsets. */
+
+void
+mn10300_virtual_frame_pointer (pc, reg, offset)
+ CORE_ADDR pc;
+ long *reg;
+ long *offset;
+{
+ struct frame_info *dummy = analyze_dummy_frame (pc, 0);
+ /* Set up a dummy frame_info, Analyze the prolog and fill in the
+ extra info. */
+ /* Results will tell us which type of frame it uses. */
+ if (dummy->extra_info->status & MY_FRAME_IN_SP)
+ {
+ *reg = SP_REGNUM;
+ *offset = -(dummy->extra_info->stack_size);
+ }
+ else
+ {
+ *reg = A3_REGNUM;
+ *offset = 0;
+ }
+}
+
/* This can be made more generic later. */
static void
set_machine_hook (filename)
if (bfd_get_mach (exec_bfd) == bfd_mach_mn10300
|| bfd_get_mach (exec_bfd) == 0)
{
- for (i = 0; i < NUM_REGS; i++)
- reg_names[i] = mn10300_generic_register_names[i];
+ mn10300_register_names = mn10300_generic_register_names;
}
- /* start-sanitize-am33 */
- am33_mode = 0;
- if (bfd_get_mach (exec_bfd) == bfd_mach_am33)
- {
- for (i = 0; i < NUM_REGS; i++)
- reg_names[i] = am33_register_names[i];
- am33_mode = 1;
- }
- /* end-sanitize-am33 */
}
void
projects / thirdparty / binutils-gdb.git / blobdiff