/* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
- Software Foundation, Inc.
+ Copyright (C) 1996-2005, 2007-2012 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "frame.h"
-#include "inferior.h"
-#include "target.h"
-#include "value.h"
-#include "bfd.h"
-#include "gdb_string.h"
-#include "gdbcore.h"
-#include "objfiles.h"
-#include "regcache.h"
#include "arch-utils.h"
-#include "gdb_assert.h"
#include "dis-asm.h"
+#include "gdbtypes.h"
+#include "regcache.h"
+#include "gdb_string.h"
+#include "gdb_assert.h"
+#include "gdbcore.h" /* For write_memory_unsigned_integer. */
+#include "value.h"
+#include "gdbtypes.h"
+#include "frame.h"
+#include "frame-unwind.h"
+#include "frame-base.h"
+#include "symtab.h"
+#include "dwarf2-frame.h"
+#include "osabi.h"
+#include "infcall.h"
+#include "prologue-value.h"
+#include "target.h"
-#define D0_REGNUM 0
-#define D2_REGNUM 2
-#define D3_REGNUM 3
-#define A0_REGNUM 4
-#define A2_REGNUM 6
-#define A3_REGNUM 7
-#define MDR_REGNUM 10
-#define PSW_REGNUM 11
-#define LIR_REGNUM 12
-#define LAR_REGNUM 13
-#define MDRQ_REGNUM 14
-#define E0_REGNUM 15
-#define MCRH_REGNUM 26
-#define MCRL_REGNUM 27
-#define MCVF_REGNUM 28
-
-enum movm_register_bits {
- movm_exother_bit = 0x01,
- movm_exreg1_bit = 0x02,
- movm_exreg0_bit = 0x04,
- movm_other_bit = 0x08,
- movm_a3_bit = 0x10,
- movm_a2_bit = 0x20,
- movm_d3_bit = 0x40,
- movm_d2_bit = 0x80
-};
-
-extern void _initialize_mn10300_tdep (void);
-static CORE_ADDR mn10300_analyze_prologue (struct frame_info *fi,
- CORE_ADDR pc);
-
-/* mn10300 private data */
-struct gdbarch_tdep
-{
- int am33_mode;
-#define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
-};
-
-/* Additional info used by the frame */
-
-struct frame_extra_info
- {
- int status;
- int stack_size;
- };
-
-
-static char *
-register_name (int reg, char **regs, long sizeof_regs)
-{
- if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
- return NULL;
- else
- return regs[reg];
-}
-
-static const char *
-mn10300_generic_register_name (int reg)
-{
- static char *regs[] =
- { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
- "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
- "", "", "", "", "", "", "", "",
- "", "", "", "", "", "", "", "fp"
- };
- return register_name (reg, regs, sizeof regs);
-}
-
-
-static const char *
-am33_register_name (int reg)
-{
- static char *regs[] =
- { "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", "", "", ""
- };
- return register_name (reg, regs, sizeof regs);
-}
-
-static CORE_ADDR
-mn10300_saved_pc_after_call (struct frame_info *fi)
-{
- return read_memory_integer (read_register (SP_REGNUM), 4);
-}
-
-static void
-mn10300_extract_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache, void *valbuf)
-{
- char buf[MAX_REGISTER_SIZE];
- int len = TYPE_LENGTH (type);
- int reg, regsz;
-
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
- reg = 4;
- else
- reg = 0;
-
- regsz = register_size (gdbarch, reg);
- if (len <= regsz)
- {
- regcache_raw_read (regcache, reg, buf);
- memcpy (valbuf, buf, len);
- }
- else if (len <= 2 * regsz)
- {
- regcache_raw_read (regcache, reg, buf);
- memcpy (valbuf, buf, regsz);
- gdb_assert (regsz == register_size (gdbarch, reg + 1));
- regcache_raw_read (regcache, reg + 1, buf);
- memcpy ((char *) valbuf + regsz, buf, len - regsz);
- }
- else
- internal_error (__FILE__, __LINE__,
- "Cannot extract return value %d bytes long.", len);
-}
-
-static void
-mn10300_store_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache, const void *valbuf)
-{
- int len = TYPE_LENGTH (type);
- int reg, regsz;
-
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
- reg = 4;
- else
- reg = 0;
+#include "mn10300-tdep.h"
- regsz = register_size (gdbarch, reg);
- if (len <= regsz)
- regcache_raw_write_part (regcache, reg, 0, len, valbuf);
- else if (len <= 2 * regsz)
- {
- regcache_raw_write (regcache, reg, valbuf);
- gdb_assert (regsz == register_size (gdbarch, reg + 1));
- regcache_raw_write_part (regcache, reg+1, 0,
- len - regsz, (char *) valbuf + regsz);
- }
- else
- internal_error (__FILE__, __LINE__,
- "Cannot store return value %d bytes long.", len);
-}
+/* The am33-2 has 64 registers. */
+#define MN10300_MAX_NUM_REGS 64
-static struct frame_info *analyze_dummy_frame (CORE_ADDR, CORE_ADDR);
-static struct frame_info *
-analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
+/* This structure holds the results of a prologue analysis. */
+struct mn10300_prologue
{
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
- struct frame_info *dummy
- = deprecated_frame_xmalloc_with_cleanup (SIZEOF_FRAME_SAVED_REGS,
- sizeof (struct frame_extra_info));
- deprecated_update_frame_pc_hack (dummy, pc);
- deprecated_update_frame_base_hack (dummy, frame);
- get_frame_extra_info (dummy)->status = 0;
- get_frame_extra_info (dummy)->stack_size = 0;
- mn10300_analyze_prologue (dummy, pc);
- do_cleanups (old_chain);
- return dummy;
-}
+ /* The architecture for which we generated this prologue info. */
+ struct gdbarch *gdbarch;
-/* Values for frame_info.status */
+ /* The offset from the frame base to the stack pointer --- always
+ zero or negative.
+
+ Calling this a "size" is a bit misleading, but given that the
+ stack grows downwards, using offsets for everything keeps one
+ from going completely sign-crazy: you never change anything's
+ sign for an ADD instruction; always change the second operand's
+ sign for a SUB instruction; and everything takes care of
+ itself. */
+ int frame_size;
+
+ /* Non-zero if this function has initialized the frame pointer from
+ the stack pointer, zero otherwise. */
+ int has_frame_ptr;
+
+ /* If has_frame_ptr is non-zero, this is the offset from the frame
+ base to where the frame pointer points. This is always zero or
+ negative. */
+ int frame_ptr_offset;
+
+ /* The address of the first instruction at which the frame has been
+ set up and the arguments are where the debug info says they are
+ --- as best as we can tell. */
+ CORE_ADDR prologue_end;
+
+ /* reg_offset[R] is the offset from the CFA at which register R is
+ saved, or 1 if register R has not been saved. (Real values are
+ always zero or negative.) */
+ int reg_offset[MN10300_MAX_NUM_REGS];
+};
-#define MY_FRAME_IN_SP 0x1
-#define MY_FRAME_IN_FP 0x2
-#define NO_MORE_FRAMES 0x4
/* Compute the alignment required by a type. */
return mn10300_type_align (check_typedef (type));
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
}
}
}
+static void
+mn10300_store_return_value (struct gdbarch *gdbarch, struct type *type,
+ struct regcache *regcache, const void *valbuf)
+{
+ int len = TYPE_LENGTH (type);
+ int reg, regsz;
+
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ reg = 4;
+ else
+ reg = 0;
+
+ regsz = register_size (gdbarch, reg);
+
+ if (len <= regsz)
+ regcache_raw_write_part (regcache, reg, 0, len, valbuf);
+ else if (len <= 2 * regsz)
+ {
+ regcache_raw_write (regcache, reg, valbuf);
+ gdb_assert (regsz == register_size (gdbarch, reg + 1));
+ regcache_raw_write_part (regcache, reg+1, 0,
+ len - regsz, (char *) valbuf + regsz);
+ }
+ else
+ internal_error (__FILE__, __LINE__,
+ _("Cannot store return value %d bytes long."), len);
+}
+
+static void
+mn10300_extract_return_value (struct gdbarch *gdbarch, struct type *type,
+ struct regcache *regcache, void *valbuf)
+{
+ char buf[MAX_REGISTER_SIZE];
+ int len = TYPE_LENGTH (type);
+ int reg, regsz;
+
+ if (TYPE_CODE (type) == TYPE_CODE_PTR)
+ reg = 4;
+ else
+ reg = 0;
+
+ regsz = register_size (gdbarch, reg);
+ if (len <= regsz)
+ {
+ regcache_raw_read (regcache, reg, buf);
+ memcpy (valbuf, buf, len);
+ }
+ else if (len <= 2 * regsz)
+ {
+ regcache_raw_read (regcache, reg, buf);
+ memcpy (valbuf, buf, regsz);
+ gdb_assert (regsz == register_size (gdbarch, reg + 1));
+ regcache_raw_read (regcache, reg + 1, buf);
+ memcpy ((char *) valbuf + regsz, buf, len - regsz);
+ }
+ else
+ internal_error (__FILE__, __LINE__,
+ _("Cannot extract return value %d bytes long."), len);
+}
+
/* Determine, for architecture GDBARCH, how a return value of TYPE
should be returned. If it is supposed to be returned in registers,
and READBUF is non-zero, read the appropriate value from REGCACHE,
from WRITEBUF into REGCACHE. */
static enum return_value_convention
-mn10300_return_value (struct gdbarch *gdbarch, struct type *type,
- struct regcache *regcache, void *readbuf,
- const void *writebuf)
+mn10300_return_value (struct gdbarch *gdbarch, struct value *function,
+ struct type *type, struct regcache *regcache,
+ gdb_byte *readbuf, const gdb_byte *writebuf)
{
if (mn10300_use_struct_convention (type))
return RETURN_VALUE_STRUCT_CONVENTION;
return RETURN_VALUE_REGISTER_CONVENTION;
}
+static char *
+register_name (int reg, char **regs, long sizeof_regs)
+{
+ if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
+ return NULL;
+ else
+ return regs[reg];
+}
+
+static const char *
+mn10300_generic_register_name (struct gdbarch *gdbarch, int reg)
+{
+ static char *regs[] =
+ { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
+ "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
+ "", "", "", "", "", "", "", "",
+ "", "", "", "", "", "", "", "fp"
+ };
+ return register_name (reg, regs, sizeof regs);
+}
+
+
+static const char *
+am33_register_name (struct gdbarch *gdbarch, int reg)
+{
+ static char *regs[] =
+ { "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", "", "", ""
+ };
+ return register_name (reg, regs, sizeof regs);
+}
+
+static const char *
+am33_2_register_name (struct gdbarch *gdbarch, int reg)
+{
+ static char *regs[] =
+ {
+ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
+ "sp", "pc", "mdr", "psw", "lir", "lar", "mdrq", "r0",
+ "r1", "r2", "r3", "r4", "r5", "r6", "r7", "ssp",
+ "msp", "usp", "mcrh", "mcrl", "mcvf", "fpcr", "", "",
+ "fs0", "fs1", "fs2", "fs3", "fs4", "fs5", "fs6", "fs7",
+ "fs8", "fs9", "fs10", "fs11", "fs12", "fs13", "fs14", "fs15",
+ "fs16", "fs17", "fs18", "fs19", "fs20", "fs21", "fs22", "fs23",
+ "fs24", "fs25", "fs26", "fs27", "fs28", "fs29", "fs30", "fs31"
+ };
+ return register_name (reg, regs, sizeof regs);
+}
+
+static struct type *
+mn10300_register_type (struct gdbarch *gdbarch, int reg)
+{
+ return builtin_type (gdbarch)->builtin_int;
+}
+
+static CORE_ADDR
+mn10300_read_pc (struct regcache *regcache)
+{
+ ULONGEST val;
+ regcache_cooked_read_unsigned (regcache, E_PC_REGNUM, &val);
+ return val;
+}
+
+static void
+mn10300_write_pc (struct regcache *regcache, CORE_ADDR val)
+{
+ regcache_cooked_write_unsigned (regcache, E_PC_REGNUM, val);
+}
+
/* The breakpoint instruction must be the same size as the smallest
instruction in the instruction set.
one, so we defined it ourselves. */
const static unsigned char *
-mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
+mn10300_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
+ int *bp_size)
{
- static char breakpoint[] =
- {0xff};
+ 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. */
-
+/* Model the semantics of pushing a register onto the stack. This
+ is a helper function for mn10300_analyze_prologue, below. */
static void
-fix_frame_pointer (struct frame_info *fi, int stack_size)
+push_reg (pv_t *regs, struct pv_area *stack, int regnum)
{
- if (fi && get_next_frame (fi) == NULL)
- {
- if (get_frame_extra_info (fi)->status & MY_FRAME_IN_SP)
- deprecated_update_frame_base_hack (fi, read_sp () - stack_size);
- else if (get_frame_extra_info (fi)->status & MY_FRAME_IN_FP)
- deprecated_update_frame_base_hack (fi, read_register (A3_REGNUM));
- }
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], -4);
+ pv_area_store (stack, regs[E_SP_REGNUM], 4, regs[regnum]);
}
+/* Translate an "r" register number extracted from an instruction encoding
+ into a GDB register number. Adapted from a simulator function
+ of the same name; see am33.igen. */
+static int
+translate_rreg (int rreg)
+{
+ /* The higher register numbers actually correspond to the
+ basic machine's address and data registers. */
+ if (rreg > 7 && rreg < 12)
+ return E_A0_REGNUM + rreg - 8;
+ else if (rreg > 11 && rreg < 16)
+ return E_D0_REGNUM + rreg - 12;
+ else
+ return E_E0_REGNUM + rreg;
+}
-/* Set offsets of registers saved by movm instruction.
- This is a helper function for mn10300_analyze_prologue. */
+/* Find saved registers in a 'struct pv_area'; we pass this to pv_area_scan.
+ If VALUE is a saved register, ADDR says it was saved at a constant
+ offset from the frame base, and SIZE indicates that the whole
+ register was saved, record its offset in RESULT_UNTYPED. */
static void
-set_movm_offsets (struct frame_info *fi, int movm_args)
+check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
{
- int offset = 0;
+ struct mn10300_prologue *result = (struct mn10300_prologue *) result_untyped;
- if (fi == NULL || movm_args == 0)
- return;
+ if (value.kind == pvk_register
+ && value.k == 0
+ && pv_is_register (addr, E_SP_REGNUM)
+ && size == register_size (result->gdbarch, value.reg))
+ result->reg_offset[value.reg] = addr.k;
+}
- if (movm_args & movm_other_bit)
- {
- /* The `other' bit leaves a blank area of four bytes at the
- beginning of its block of saved registers, making it 32 bytes
- long in total. */
- deprecated_get_frame_saved_regs (fi)[LAR_REGNUM] = get_frame_base (fi) + offset + 4;
- deprecated_get_frame_saved_regs (fi)[LIR_REGNUM] = get_frame_base (fi) + offset + 8;
- deprecated_get_frame_saved_regs (fi)[MDR_REGNUM] = get_frame_base (fi) + offset + 12;
- deprecated_get_frame_saved_regs (fi)[A0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
- deprecated_get_frame_saved_regs (fi)[A0_REGNUM] = get_frame_base (fi) + offset + 20;
- deprecated_get_frame_saved_regs (fi)[D0_REGNUM + 1] = get_frame_base (fi) + offset + 24;
- deprecated_get_frame_saved_regs (fi)[D0_REGNUM] = get_frame_base (fi) + offset + 28;
- offset += 32;
- }
- if (movm_args & movm_a3_bit)
- {
- deprecated_get_frame_saved_regs (fi)[A3_REGNUM] = get_frame_base (fi) + offset;
- offset += 4;
- }
- if (movm_args & movm_a2_bit)
- {
- deprecated_get_frame_saved_regs (fi)[A2_REGNUM] = get_frame_base (fi) + offset;
- offset += 4;
- }
- if (movm_args & movm_d3_bit)
- {
- deprecated_get_frame_saved_regs (fi)[D3_REGNUM] = get_frame_base (fi) + offset;
- offset += 4;
- }
- if (movm_args & movm_d2_bit)
+/* Analyze the prologue to determine where registers are saved,
+ the end of the prologue, etc. The result of this analysis is
+ returned in RESULT. See struct mn10300_prologue above for more
+ information. */
+static void
+mn10300_analyze_prologue (struct gdbarch *gdbarch,
+ CORE_ADDR start_pc, CORE_ADDR limit_pc,
+ struct mn10300_prologue *result)
+{
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ CORE_ADDR pc;
+ int rn;
+ pv_t regs[MN10300_MAX_NUM_REGS];
+ struct pv_area *stack;
+ struct cleanup *back_to;
+ CORE_ADDR after_last_frame_setup_insn = start_pc;
+ int am33_mode = AM33_MODE (gdbarch);
+
+ memset (result, 0, sizeof (*result));
+ result->gdbarch = gdbarch;
+
+ for (rn = 0; rn < MN10300_MAX_NUM_REGS; rn++)
{
- deprecated_get_frame_saved_regs (fi)[D2_REGNUM] = get_frame_base (fi) + offset;
- offset += 4;
+ regs[rn] = pv_register (rn, 0);
+ result->reg_offset[rn] = 1;
}
- if (AM33_MODE)
+ stack = make_pv_area (E_SP_REGNUM, gdbarch_addr_bit (gdbarch));
+ back_to = make_cleanup_free_pv_area (stack);
+
+ /* The typical call instruction will have saved the return address on the
+ stack. Space for the return address has already been preallocated in
+ the caller's frame. It's possible, such as when using -mrelax with gcc
+ that other registers were saved as well. If this happens, we really
+ have no chance of deciphering the frame. DWARF info can save the day
+ when this happens. */
+ pv_area_store (stack, regs[E_SP_REGNUM], 4, regs[E_PC_REGNUM]);
+
+ pc = start_pc;
+ while (pc < limit_pc)
{
- if (movm_args & movm_exother_bit)
- {
- deprecated_get_frame_saved_regs (fi)[MCVF_REGNUM] = get_frame_base (fi) + offset;
- deprecated_get_frame_saved_regs (fi)[MCRL_REGNUM] = get_frame_base (fi) + offset + 4;
- deprecated_get_frame_saved_regs (fi)[MCRH_REGNUM] = get_frame_base (fi) + offset + 8;
- deprecated_get_frame_saved_regs (fi)[MDRQ_REGNUM] = get_frame_base (fi) + offset + 12;
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 1] = get_frame_base (fi) + offset + 16;
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 0] = get_frame_base (fi) + offset + 20;
- offset += 24;
- }
- if (movm_args & movm_exreg1_bit)
- {
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 7] = get_frame_base (fi) + offset;
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 6] = get_frame_base (fi) + offset + 4;
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 5] = get_frame_base (fi) + offset + 8;
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 4] = get_frame_base (fi) + offset + 12;
- offset += 16;
- }
- if (movm_args & movm_exreg0_bit)
- {
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 3] = get_frame_base (fi) + offset;
- deprecated_get_frame_saved_regs (fi)[E0_REGNUM + 2] = get_frame_base (fi) + offset + 4;
- offset += 8;
- }
- }
-}
+ int status;
+ gdb_byte instr[2];
+
+ /* Instructions can be as small as one byte; however, we usually
+ need at least two bytes to do the decoding, so fetch that many
+ to begin with. */
+ status = target_read_memory (pc, instr, 2);
+ if (status != 0)
+ break;
+
+ /* movm [regs], sp */
+ if (instr[0] == 0xcf)
+ {
+ gdb_byte save_mask;
+
+ save_mask = instr[1];
+
+ if ((save_mask & movm_exreg0_bit) && am33_mode)
+ {
+ push_reg (regs, stack, E_E2_REGNUM);
+ push_reg (regs, stack, E_E3_REGNUM);
+ }
+ if ((save_mask & movm_exreg1_bit) && am33_mode)
+ {
+ push_reg (regs, stack, E_E4_REGNUM);
+ push_reg (regs, stack, E_E5_REGNUM);
+ push_reg (regs, stack, E_E6_REGNUM);
+ push_reg (regs, stack, E_E7_REGNUM);
+ }
+ if ((save_mask & movm_exother_bit) && am33_mode)
+ {
+ push_reg (regs, stack, E_E0_REGNUM);
+ push_reg (regs, stack, E_E1_REGNUM);
+ push_reg (regs, stack, E_MDRQ_REGNUM);
+ push_reg (regs, stack, E_MCRH_REGNUM);
+ push_reg (regs, stack, E_MCRL_REGNUM);
+ push_reg (regs, stack, E_MCVF_REGNUM);
+ }
+ if (save_mask & movm_d2_bit)
+ push_reg (regs, stack, E_D2_REGNUM);
+ if (save_mask & movm_d3_bit)
+ push_reg (regs, stack, E_D3_REGNUM);
+ if (save_mask & movm_a2_bit)
+ push_reg (regs, stack, E_A2_REGNUM);
+ if (save_mask & movm_a3_bit)
+ push_reg (regs, stack, E_A3_REGNUM);
+ if (save_mask & movm_other_bit)
+ {
+ push_reg (regs, stack, E_D0_REGNUM);
+ push_reg (regs, stack, E_D1_REGNUM);
+ push_reg (regs, stack, E_A0_REGNUM);
+ push_reg (regs, stack, E_A1_REGNUM);
+ push_reg (regs, stack, E_MDR_REGNUM);
+ push_reg (regs, stack, E_LIR_REGNUM);
+ push_reg (regs, stack, E_LAR_REGNUM);
+ /* The `other' bit leaves a blank area of four bytes at
+ the beginning of its block of saved registers, making
+ it 32 bytes long in total. */
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], -4);
+ }
+
+ pc += 2;
+ after_last_frame_setup_insn = pc;
+ }
+ /* mov sp, aN */
+ else if ((instr[0] & 0xfc) == 0x3c)
+ {
+ int aN = instr[0] & 0x03;
+
+ regs[E_A0_REGNUM + aN] = regs[E_SP_REGNUM];
+
+ pc += 1;
+ if (aN == 3)
+ after_last_frame_setup_insn = pc;
+ }
+ /* mov aM, aN */
+ else if ((instr[0] & 0xf0) == 0x90
+ && (instr[0] & 0x03) != ((instr[0] & 0x0c) >> 2))
+ {
+ int aN = instr[0] & 0x03;
+ int aM = (instr[0] & 0x0c) >> 2;
+
+ regs[E_A0_REGNUM + aN] = regs[E_A0_REGNUM + aM];
+
+ pc += 1;
+ }
+ /* mov dM, dN */
+ else if ((instr[0] & 0xf0) == 0x80
+ && (instr[0] & 0x03) != ((instr[0] & 0x0c) >> 2))
+ {
+ int dN = instr[0] & 0x03;
+ int dM = (instr[0] & 0x0c) >> 2;
+
+ regs[E_D0_REGNUM + dN] = regs[E_D0_REGNUM + dM];
+
+ pc += 1;
+ }
+ /* mov aM, dN */
+ else if (instr[0] == 0xf1 && (instr[1] & 0xf0) == 0xd0)
+ {
+ int dN = instr[1] & 0x03;
+ int aM = (instr[1] & 0x0c) >> 2;
+
+ regs[E_D0_REGNUM + dN] = regs[E_A0_REGNUM + aM];
+
+ pc += 2;
+ }
+ /* mov dM, aN */
+ else if (instr[0] == 0xf1 && (instr[1] & 0xf0) == 0xe0)
+ {
+ int aN = instr[1] & 0x03;
+ int dM = (instr[1] & 0x0c) >> 2;
+
+ regs[E_A0_REGNUM + aN] = regs[E_D0_REGNUM + dM];
+
+ pc += 2;
+ }
+ /* add imm8, SP */
+ else if (instr[0] == 0xf8 && instr[1] == 0xfe)
+ {
+ gdb_byte buf[1];
+ LONGEST imm8;
+
+
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
+
+ imm8 = extract_signed_integer (buf, 1, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm8);
+
+ pc += 3;
+ /* Stack pointer adjustments are frame related. */
+ after_last_frame_setup_insn = pc;
+ }
+ /* add imm16, SP */
+ else if (instr[0] == 0xfa && instr[1] == 0xfe)
+ {
+ gdb_byte buf[2];
+ LONGEST imm16;
+
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
+
+ imm16 = extract_signed_integer (buf, 2, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm16);
+
+ pc += 4;
+ /* Stack pointer adjustments are frame related. */
+ after_last_frame_setup_insn = pc;
+ }
+ /* add imm32, SP */
+ else if (instr[0] == 0xfc && instr[1] == 0xfe)
+ {
+ gdb_byte buf[4];
+ LONGEST imm32;
+
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
+
+
+ imm32 = extract_signed_integer (buf, 4, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm32);
+
+ pc += 6;
+ /* Stack pointer adjustments are frame related. */
+ after_last_frame_setup_insn = pc;
+ }
+ /* add imm8, aN */
+ else if ((instr[0] & 0xfc) == 0x20)
+ {
+ int aN;
+ LONGEST imm8;
+
+ aN = instr[0] & 0x03;
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
+
+ regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
+ imm8);
+
+ pc += 2;
+ }
+ /* add imm16, aN */
+ else if (instr[0] == 0xfa && (instr[1] & 0xfc) == 0xd0)
+ {
+ int aN;
+ LONGEST imm16;
+ gdb_byte buf[2];
+
+ aN = instr[1] & 0x03;
+
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
+
+
+ imm16 = extract_signed_integer (buf, 2, byte_order);
+
+ regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
+ imm16);
+
+ pc += 4;
+ }
+ /* add imm32, aN */
+ else if (instr[0] == 0xfc && (instr[1] & 0xfc) == 0xd0)
+ {
+ int aN;
+ LONGEST imm32;
+ gdb_byte buf[4];
+
+ aN = instr[1] & 0x03;
+
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
+
+ imm32 = extract_signed_integer (buf, 2, byte_order);
+
+ regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
+ imm32);
+ pc += 6;
+ }
+ /* fmov fsM, (rN) */
+ else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x30)
+ {
+ int fsM, sM, Y, rN;
+ gdb_byte buf[1];
+
+ Y = (instr[1] & 0x02) >> 1;
+
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
+
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+
+ pv_area_store (stack, regs[translate_rreg (rN)], 4,
+ regs[E_FS0_REGNUM + fsM]);
+
+ pc += 3;
+ }
+ /* fmov fsM, (sp) */
+ else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x34)
+ {
+ int fsM, sM, Y;
+ gdb_byte buf[1];
+
+ Y = (instr[1] & 0x02) >> 1;
+
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
-/* The main purpose of this file is dealing with prologues to extract
- information about stack frames and saved registers.
+ pv_area_store (stack, regs[E_SP_REGNUM], 4,
+ regs[E_FS0_REGNUM + fsM]);
- In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
- function is pretty readable, and has a nice explanation of how the
- prologue is generated. The prologues generated by that code will
- have the following form (NOTE: the current code doesn't handle all
- this!):
+ pc += 3;
+ }
+ /* fmov fsM, (rN, rI) */
+ else if (instr[0] == 0xfb && instr[1] == 0x37)
+ {
+ int fsM, sM, Z, rN, rI;
+ gdb_byte buf[2];
- + If this is an old-style varargs function, then its arguments
- need to be flushed back to the stack:
-
- mov d0,(4,sp)
- mov d1,(4,sp)
- + If we use any of the callee-saved registers, save them now.
-
- movm [some callee-saved registers],(sp)
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- + If we have any floating-point registers to save:
+ rI = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ sM = (buf[1] & 0xf0) >> 4;
+ Z = (buf[1] & 0x02) >> 1;
+ fsM = (Z << 4) | sM;
- - Decrement the stack pointer to reserve space for the registers.
- If the function doesn't need a frame pointer, we may combine
- this with the adjustment that reserves space for the frame.
+ pv_area_store (stack,
+ pv_add (regs[translate_rreg (rN)],
+ regs[translate_rreg (rI)]),
+ 4, regs[E_FS0_REGNUM + fsM]);
- add -SIZE, sp
+ pc += 4;
+ }
+ /* fmov fsM, (d8, rN) */
+ else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x30)
+ {
+ int fsM, sM, Y, rN;
+ LONGEST d8;
+ gdb_byte buf[2];
- - Save the floating-point registers. We have two possible
- strategies:
+ Y = (instr[1] & 0x02) >> 1;
- . Save them at fixed offset from the SP:
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- fmov fsN,(OFFSETN,sp)
- fmov fsM,(OFFSETM,sp)
- ...
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d8 = extract_signed_integer (&buf[1], 1, byte_order);
- Note that, if OFFSETN happens to be zero, you'll get the
- different opcode: fmov fsN,(sp)
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d8),
+ 4, regs[E_FS0_REGNUM + fsM]);
- . Or, set a0 to the start of the save area, and then use
- post-increment addressing to save the FP registers.
+ pc += 4;
+ }
+ /* fmov fsM, (d24, rN) */
+ else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x30)
+ {
+ int fsM, sM, Y, rN;
+ LONGEST d24;
+ gdb_byte buf[4];
- mov sp, a0
- add SIZE, a0
- fmov fsN,(a0+)
- fmov fsM,(a0+)
- ...
+ Y = (instr[1] & 0x02) >> 1;
- + If the function needs a frame pointer, we set it here.
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- mov sp, a3
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d24 = extract_signed_integer (&buf[1], 3, byte_order);
- + Now we reserve space for the stack frame proper. This could be
- merged into the `add -SIZE, sp' instruction for FP saves up
- above, unless we needed to set the frame pointer in the previous
- step, or the frame is so large that allocating the whole thing at
- once would put the FP register save slots out of reach of the
- addressing mode (128 bytes).
-
- add -SIZE, sp
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d24),
+ 4, regs[E_FS0_REGNUM + fsM]);
- One day we might keep the stack pointer constant, that won't
- change the code for prologues, but it will make the frame
- pointerless case much more common. */
+ pc += 6;
+ }
+ /* fmov fsM, (d32, rN) */
+ else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x30)
+ {
+ int fsM, sM, Y, rN;
+ LONGEST d32;
+ gdb_byte buf[5];
-/* Analyze the prologue to determine where registers are saved,
- the end of the prologue, etc etc. Return the end of the prologue
- scanned.
+ Y = (instr[1] & 0x02) >> 1;
- We store into FI (if non-null) several tidbits of information:
+ status = target_read_memory (pc + 2, buf, 5);
+ if (status != 0)
+ break;
- * stack_size -- size of this stack frame. Note that if we stop in
- certain parts of the prologue/epilogue we may claim the size of the
- current frame is zero. This happens when the current frame has
- not been allocated yet or has already been deallocated.
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d32 = extract_signed_integer (&buf[1], 4, byte_order);
- * fsr -- Addresses of registers saved in the stack by this frame.
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d32),
+ 4, regs[E_FS0_REGNUM + fsM]);
- * status -- A (relatively) generic status indicator. It's a bitmask
- with the following bits:
+ pc += 7;
+ }
+ /* fmov fsM, (d8, SP) */
+ else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x34)
+ {
+ int fsM, sM, Y;
+ LONGEST d8;
+ gdb_byte buf[2];
- MY_FRAME_IN_SP: The base of the current frame is actually in
- the stack pointer. This can happen for frame pointerless
- functions, or cases where we're stopped in the prologue/epilogue
- itself. For these cases mn10300_analyze_prologue will need up
- update fi->frame before returning or analyzing the register
- save instructions.
+ Y = (instr[1] & 0x02) >> 1;
- MY_FRAME_IN_FP: The base of the current frame is in the
- frame pointer register ($a3).
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- NO_MORE_FRAMES: Set this if the current frame is "start" or
- if the first instruction looks like mov <imm>,sp. This tells
- frame chain to not bother trying to unwind past this frame. */
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d8 = extract_signed_integer (&buf[1], 1, byte_order);
-static CORE_ADDR
-mn10300_analyze_prologue (struct frame_info *fi, CORE_ADDR pc)
-{
- CORE_ADDR func_addr, func_end, addr, stop;
- CORE_ADDR stack_size;
- int imm_size;
- unsigned char buf[4];
- int status, movm_args = 0;
- char *name;
-
- /* Use the PC in the frame if it's provided to look up the
- start of this function.
-
- Note: kevinb/2003-07-16: We used to do the following here:
- pc = (fi ? get_frame_pc (fi) : pc);
- But this is (now) badly broken when called from analyze_dummy_frame().
- */
- pc = (pc ? pc : get_frame_pc (fi));
-
- /* Find the start of this function. */
- status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
-
- /* Do nothing if we couldn't find the start of this function or if we're
- stopped at the first instruction in the prologue. */
- if (status == 0)
- {
- return pc;
- }
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d8),
+ 4, regs[E_FS0_REGNUM + fsM]);
- /* If we're in start, then give up. */
- if (strcmp (name, "start") == 0)
- {
- if (fi != NULL)
- get_frame_extra_info (fi)->status = NO_MORE_FRAMES;
- return pc;
- }
+ pc += 4;
+ }
+ /* fmov fsM, (d24, SP) */
+ else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x34)
+ {
+ int fsM, sM, Y;
+ LONGEST d24;
+ gdb_byte buf[4];
- /* At the start of a function our frame is in the stack pointer. */
- if (fi)
- get_frame_extra_info (fi)->status = MY_FRAME_IN_SP;
+ Y = (instr[1] & 0x02) >> 1;
- /* 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. */
- status = deprecated_read_memory_nobpt (pc, buf, 2);
- if (status != 0)
- return pc;
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
-#if 0
- /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
- changes to the frame in prologue examination code. */
- /* If we're physically on an "rets" instruction, then our frame has
- already been deallocated. Note this can also be true for retf
- and ret if they specify a size of zero.
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d24 = extract_signed_integer (&buf[1], 3, byte_order);
- In this case fi->frame is bogus, we need to fix it. */
- if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
- {
- if (get_next_frame (fi) == NULL)
- deprecated_update_frame_base_hack (fi, read_sp ());
- return get_frame_pc (fi);
- }
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d24),
+ 4, regs[E_FS0_REGNUM + fsM]);
- /* Similarly if we're stopped on the first insn of a prologue as our
- frame hasn't been allocated yet. */
- if (fi && get_frame_pc (fi) == func_addr)
- {
- if (get_next_frame (fi) == NULL)
- deprecated_update_frame_base_hack (fi, read_sp ());
- return get_frame_pc (fi);
- }
-#endif
+ pc += 6;
+ }
+ /* fmov fsM, (d32, SP) */
+ else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x34)
+ {
+ int fsM, sM, Y;
+ LONGEST d32;
+ gdb_byte buf[5];
- /* Figure out where to stop scanning. */
- stop = fi ? pc : func_end;
+ Y = (instr[1] & 0x02) >> 1;
- /* Don't walk off the end of the function. */
- stop = stop > func_end ? func_end : stop;
+ status = target_read_memory (pc + 2, buf, 5);
+ if (status != 0)
+ break;
- /* Start scanning on the first instruction of this function. */
- addr = func_addr;
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d32 = extract_signed_integer (&buf[1], 4, byte_order);
- /* Suck in two bytes. */
- if (addr + 2 >= stop
- || (status = deprecated_read_memory_nobpt (addr, buf, 2)) != 0)
- {
- fix_frame_pointer (fi, 0);
- return addr;
- }
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d32),
+ 4, regs[E_FS0_REGNUM + fsM]);
- /* First see if this insn sets the stack pointer from a register; if
- so, it's probably the initialization of the stack pointer in _start,
- so mark this as the bottom-most frame. */
- if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
- {
- if (fi)
- get_frame_extra_info (fi)->status = NO_MORE_FRAMES;
- return addr;
- }
+ pc += 7;
+ }
+ /* fmov fsM, (rN+) */
+ else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x31)
+ {
+ int fsM, sM, Y, rN, rN_regnum;
+ gdb_byte buf[1];
- /* Now look for movm [regs],sp, which saves the callee saved registers.
+ Y = (instr[1] & 0x02) >> 1;
- At this time we don't know if fi->frame is valid, so we only note
- that we encountered a movm instruction. Later, we'll set the entries
- in fsr.regs as needed. */
- if (buf[0] == 0xcf)
- {
- /* Extract the register list for the movm instruction. */
- status = deprecated_read_memory_nobpt (addr + 1, buf, 1);
- movm_args = *buf;
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
- addr += 2;
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
- /* Quit now if we're beyond the stop point. */
- if (addr >= stop)
- {
- /* Fix fi->frame since it's bogus at this point. */
- if (fi && get_next_frame (fi) == NULL)
- deprecated_update_frame_base_hack (fi, read_sp ());
+ rN_regnum = translate_rreg (rN);
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
+ pv_area_store (stack, regs[rN_regnum], 4,
+ regs[E_FS0_REGNUM + fsM]);
+ regs[rN_regnum] = pv_add_constant (regs[rN_regnum], 4);
- /* Get the next two bytes so the prologue scan can continue. */
- status = deprecated_read_memory_nobpt (addr, buf, 2);
- if (status != 0)
+ pc += 3;
+ }
+ /* fmov fsM, (rN+, imm8) */
+ else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x31)
{
- /* Fix fi->frame since it's bogus at this point. */
- if (fi && get_next_frame (fi) == NULL)
- deprecated_update_frame_base_hack (fi, read_sp ());
+ int fsM, sM, Y, rN, rN_regnum;
+ LONGEST imm8;
+ gdb_byte buf[2];
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
- }
+ Y = (instr[1] & 0x02) >> 1;
- /* Now see if we set up a frame pointer via "mov sp,a3" */
- if (buf[0] == 0x3f)
- {
- addr += 1;
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- /* The frame pointer is now valid. */
- if (fi)
- {
- get_frame_extra_info (fi)->status |= MY_FRAME_IN_FP;
- get_frame_extra_info (fi)->status &= ~MY_FRAME_IN_SP;
- }
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ imm8 = extract_signed_integer (&buf[1], 1, byte_order);
- /* Quit now if we're beyond the stop point. */
- if (addr >= stop)
- {
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ rN_regnum = translate_rreg (rN);
+
+ pv_area_store (stack, regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
+ regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm8);
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
+ pc += 4;
}
+ /* fmov fsM, (rN+, imm24) */
+ else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x31)
+ {
+ int fsM, sM, Y, rN, rN_regnum;
+ LONGEST imm24;
+ gdb_byte buf[4];
- /* Get two more bytes so scanning can continue. */
- status = deprecated_read_memory_nobpt (addr, buf, 2);
- if (status != 0)
+ Y = (instr[1] & 0x02) >> 1;
+
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
+
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ imm24 = extract_signed_integer (&buf[1], 3, byte_order);
+
+ rN_regnum = translate_rreg (rN);
+
+ pv_area_store (stack, regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
+ regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm24);
+
+ pc += 6;
+ }
+ /* fmov fsM, (rN+, imm32) */
+ else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x31)
{
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ int fsM, sM, Y, rN, rN_regnum;
+ LONGEST imm32;
+ gdb_byte buf[5];
+
+ Y = (instr[1] & 0x02) >> 1;
+
+ status = target_read_memory (pc + 2, buf, 5);
+ if (status != 0)
+ break;
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ imm32 = extract_signed_integer (&buf[1], 4, byte_order);
+
+ rN_regnum = translate_rreg (rN);
+
+ pv_area_store (stack, regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
+ regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm32);
+
+ pc += 7;
}
- }
+ /* mov imm8, aN */
+ else if ((instr[0] & 0xf0) == 0x90)
+ {
+ int aN = instr[0] & 0x03;
+ LONGEST imm8;
- /* Next we should allocate the local frame. No more prologue insns
- are found after allocating the local frame.
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
- Search for add imm8,sp (0xf8feXX)
- or add imm16,sp (0xfafeXXXX)
- or add imm32,sp (0xfcfeXXXXXXXX).
+ regs[E_A0_REGNUM + aN] = pv_constant (imm8);
+ pc += 2;
+ }
+ /* mov imm16, aN */
+ else if ((instr[0] & 0xfc) == 0x24)
+ {
+ int aN = instr[0] & 0x03;
+ gdb_byte buf[2];
+ LONGEST imm16;
- If none of the above was found, then this prologue has no
- additional stack. */
+ status = target_read_memory (pc + 1, buf, 2);
+ if (status != 0)
+ break;
- status = deprecated_read_memory_nobpt (addr, buf, 2);
- if (status != 0)
- {
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ imm16 = extract_signed_integer (buf, 2, byte_order);
+ regs[E_A0_REGNUM + aN] = pv_constant (imm16);
+ pc += 3;
+ }
+ /* mov imm32, aN */
+ else if (instr[0] == 0xfc && ((instr[1] & 0xfc) == 0xdc))
+ {
+ int aN = instr[1] & 0x03;
+ gdb_byte buf[4];
+ LONGEST imm32;
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- imm_size = 0;
- if (buf[0] == 0xf8 && buf[1] == 0xfe)
- imm_size = 1;
- else if (buf[0] == 0xfa && buf[1] == 0xfe)
- imm_size = 2;
- else if (buf[0] == 0xfc && buf[1] == 0xfe)
- imm_size = 4;
+ imm32 = extract_signed_integer (buf, 4, byte_order);
+ regs[E_A0_REGNUM + aN] = pv_constant (imm32);
+ pc += 6;
+ }
+ /* mov imm8, dN */
+ else if ((instr[0] & 0xf0) == 0x80)
+ {
+ int dN = instr[0] & 0x03;
+ LONGEST imm8;
- if (imm_size != 0)
- {
- /* Suck in imm_size more bytes, they'll hold the size of the
- current frame. */
- status = deprecated_read_memory_nobpt (addr + 2, buf, imm_size);
- if (status != 0)
- {
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
+ regs[E_D0_REGNUM + dN] = pv_constant (imm8);
+ pc += 2;
}
+ /* mov imm16, dN */
+ else if ((instr[0] & 0xfc) == 0x2c)
+ {
+ int dN = instr[0] & 0x03;
+ gdb_byte buf[2];
+ LONGEST imm16;
- /* Note the size of the stack in the frame info structure. */
- stack_size = extract_signed_integer (buf, imm_size);
- if (fi)
- get_frame_extra_info (fi)->stack_size = stack_size;
+ status = target_read_memory (pc + 1, buf, 2);
+ if (status != 0)
+ break;
- /* We just consumed 2 + imm_size bytes. */
- addr += 2 + imm_size;
+ imm16 = extract_signed_integer (buf, 2, byte_order);
+ regs[E_D0_REGNUM + dN] = pv_constant (imm16);
+ pc += 3;
+ }
+ /* mov imm32, dN */
+ else if (instr[0] == 0xfc && ((instr[1] & 0xfc) == 0xcc))
+ {
+ int dN = instr[1] & 0x03;
+ gdb_byte buf[4];
+ LONGEST imm32;
- /* No more prologue insns follow, so begin preparation to return. */
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, stack_size);
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
+ imm32 = extract_signed_integer (buf, 4, byte_order);
+ regs[E_D0_REGNUM + dN] = pv_constant (imm32);
+ pc += 6;
+ }
+ else
+ {
+ /* We've hit some instruction that we don't recognize. Hopefully,
+ we have enough to do prologue analysis. */
+ break;
+ }
}
- /* We never found an insn which allocates local stack space, regardless
- this is the end of the prologue. */
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
-
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
-}
+ /* Is the frame size (offset, really) a known constant? */
+ if (pv_is_register (regs[E_SP_REGNUM], E_SP_REGNUM))
+ result->frame_size = regs[E_SP_REGNUM].k;
+ /* Was the frame pointer initialized? */
+ if (pv_is_register (regs[E_A3_REGNUM], E_SP_REGNUM))
+ {
+ result->has_frame_ptr = 1;
+ result->frame_ptr_offset = regs[E_A3_REGNUM].k;
+ }
-/* Function: saved_regs_size
- Return the size in bytes of the register save area, based on the
- saved_regs array in FI. */
-static int
-saved_regs_size (struct frame_info *fi)
-{
- int adjust = 0;
- int i;
-
- /* Reserve four bytes for every register saved. */
- for (i = 0; i < NUM_REGS; i++)
- if (deprecated_get_frame_saved_regs (fi)[i])
- adjust += 4;
-
- /* If we saved LIR, then it's most likely we used a `movm'
- instruction with the `other' bit set, in which case the SP is
- decremented by an extra four bytes, "to simplify calculation
- of the transfer area", according to the processor manual. */
- if (deprecated_get_frame_saved_regs (fi)[LIR_REGNUM])
- adjust += 4;
-
- return adjust;
-}
+ /* Record where all the registers were saved. */
+ pv_area_scan (stack, check_for_saved, (void *) result);
+ result->prologue_end = after_last_frame_setup_insn;
-/* Function: frame_chain
- Figure out and return the caller's frame pointer given current
- frame_info struct.
+ do_cleanups (back_to);
+}
- We don't handle dummy frames yet but we would probably just return the
- stack pointer that was in use at the time the function call was made? */
+/* Function: skip_prologue
+ Return the address of the first inst past the prologue of the function. */
static CORE_ADDR
-mn10300_frame_chain (struct frame_info *fi)
+mn10300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
- struct frame_info *dummy;
- /* Walk through the prologue to determine the stack size,
- location of saved registers, end of the prologue, etc. */
- if (get_frame_extra_info (fi)->status == 0)
- mn10300_analyze_prologue (fi, (CORE_ADDR) 0);
+ const char *name;
+ CORE_ADDR func_addr, func_end;
+ struct mn10300_prologue p;
+
+ /* Try to find the extent of the function that contains PC. */
+ if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
+ return pc;
- /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
- if (get_frame_extra_info (fi)->status & NO_MORE_FRAMES)
- return 0;
+ mn10300_analyze_prologue (gdbarch, pc, func_end, &p);
+ return p.prologue_end;
+}
- /* Now that we've analyzed our prologue, determine the frame
- pointer for our caller.
+/* Wrapper for mn10300_analyze_prologue: find the function start;
+ use the current frame PC as the limit, then
+ invoke mn10300_analyze_prologue and return its result. */
+static struct mn10300_prologue *
+mn10300_analyze_frame_prologue (struct frame_info *this_frame,
+ void **this_prologue_cache)
+{
+ if (!*this_prologue_cache)
+ {
+ CORE_ADDR func_start, stop_addr;
- If our caller has a frame pointer, then we need to
- find the entry value of $a3 to our function.
+ *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct mn10300_prologue);
- If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
- location pointed to by fsr.regs[A3_REGNUM].
+ func_start = get_frame_func (this_frame);
+ stop_addr = get_frame_pc (this_frame);
- Else it's still in $a3.
+ /* If we couldn't find any function containing the PC, then
+ just initialize the prologue cache, but don't do anything. */
+ if (!func_start)
+ stop_addr = func_start;
- If our caller does not have a frame pointer, then his
- frame base is fi->frame + -caller's stack size. */
+ mn10300_analyze_prologue (get_frame_arch (this_frame),
+ func_start, stop_addr, *this_prologue_cache);
+ }
- /* 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 = analyze_dummy_frame (DEPRECATED_FRAME_SAVED_PC (fi), get_frame_base (fi));
+ return *this_prologue_cache;
+}
- if (get_frame_extra_info (dummy)->status & MY_FRAME_IN_FP)
+/* Given the next frame and a prologue cache, return this frame's
+ base. */
+static CORE_ADDR
+mn10300_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
+{
+ struct mn10300_prologue *p
+ = mn10300_analyze_frame_prologue (this_frame, this_prologue_cache);
+
+ /* In functions that use alloca, the distance between the stack
+ pointer and the frame base varies dynamically, so we can't use
+ the SP plus static information like prologue analysis to find the
+ frame base. However, such functions must have a frame pointer,
+ to be able to restore the SP on exit. So whenever we do have a
+ frame pointer, use that to find the base. */
+ if (p->has_frame_ptr)
{
- /* Our caller has a frame pointer. So find the frame in $a3 or
- in the stack. */
- if (deprecated_get_frame_saved_regs (fi)[A3_REGNUM])
- return (read_memory_integer (deprecated_get_frame_saved_regs (fi)[A3_REGNUM],
- DEPRECATED_REGISTER_SIZE));
- else
- return read_register (A3_REGNUM);
+ CORE_ADDR fp = get_frame_register_unsigned (this_frame, E_A3_REGNUM);
+ return fp - p->frame_ptr_offset;
}
else
{
- int adjust = saved_regs_size (fi);
-
- /* 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 get_frame_base (fi) + adjust + -get_frame_extra_info (dummy)->stack_size;
+ CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
+ return sp - p->frame_size;
}
}
-/* Function: skip_prologue
- Return the address of the first inst past the prologue of the function. */
-
-static CORE_ADDR
-mn10300_skip_prologue (CORE_ADDR pc)
+/* Here is a dummy implementation. */
+static struct frame_id
+mn10300_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
- /* We used to check the debug symbols, but that can lose if
- we have a null prologue. */
- return mn10300_analyze_prologue (NULL, pc);
+ CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
+ CORE_ADDR pc = get_frame_register_unsigned (this_frame, E_PC_REGNUM);
+ return frame_id_build (sp, pc);
}
-/* generic_pop_current_frame calls this function if the current
- frame isn't a dummy frame. */
static void
-mn10300_pop_frame_regular (struct frame_info *frame)
+mn10300_frame_this_id (struct frame_info *this_frame,
+ void **this_prologue_cache,
+ struct frame_id *this_id)
{
- int regnum;
+ *this_id = frame_id_build (mn10300_frame_base (this_frame,
+ this_prologue_cache),
+ get_frame_func (this_frame));
- write_register (PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
+}
+
+static struct value *
+mn10300_frame_prev_register (struct frame_info *this_frame,
+ void **this_prologue_cache, int regnum)
+{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (get_frame_arch (this_frame));
+ struct mn10300_prologue *p
+ = mn10300_analyze_frame_prologue (this_frame, this_prologue_cache);
+ CORE_ADDR frame_base = mn10300_frame_base (this_frame, this_prologue_cache);
+ int reg_size = register_size (get_frame_arch (this_frame), regnum);
+
+ if (regnum == E_SP_REGNUM)
+ return frame_unwind_got_constant (this_frame, regnum, frame_base);
+
+ /* If prologue analysis says we saved this register somewhere,
+ return a description of the stack slot holding it. */
+ if (p->reg_offset[regnum] != 1)
+ return frame_unwind_got_memory (this_frame, regnum,
+ frame_base + p->reg_offset[regnum]);
+
+ /* Otherwise, presume we haven't changed the value of this
+ register, and get it from the next frame. */
+ return frame_unwind_got_register (this_frame, regnum, regnum);
+}
+
+static const struct frame_unwind mn10300_frame_unwind = {
+ NORMAL_FRAME,
+ default_frame_unwind_stop_reason,
+ mn10300_frame_this_id,
+ mn10300_frame_prev_register,
+ NULL,
+ default_frame_sniffer
+};
+
+static CORE_ADDR
+mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
+{
+ ULONGEST pc;
- /* Restore any saved registers. */
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
- {
- ULONGEST value;
+ pc = frame_unwind_register_unsigned (this_frame, E_PC_REGNUM);
+ return pc;
+}
- value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
- register_size (current_gdbarch, regnum));
- write_register (regnum, value);
- }
+static CORE_ADDR
+mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
+{
+ ULONGEST sp;
- /* Actually cut back the stack, adjusted by the saved registers like
- ret would. */
- write_register (SP_REGNUM, get_frame_base (frame) + saved_regs_size (frame));
+ sp = frame_unwind_register_unsigned (this_frame, E_SP_REGNUM);
+ return sp;
}
-/* Function: pop_frame
- This routine gets called when either the user uses the `return'
- command, or the call dummy breakpoint gets hit. */
static void
-mn10300_pop_frame (void)
+mn10300_frame_unwind_init (struct gdbarch *gdbarch)
{
- struct frame_info *frame = get_current_frame ();
- if (get_frame_type (frame) == DUMMY_FRAME)
- /* NOTE: cagney/2002-22-23: Does this ever occure? Surely a dummy
- frame will have already been poped by the "infrun.c" code. */
- deprecated_pop_dummy_frame ();
- else
- mn10300_pop_frame_regular (frame);
- /* Throw away any cached frame information. */
- flush_cached_frames ();
+ dwarf2_append_unwinders (gdbarch);
+ frame_unwind_append_unwinder (gdbarch, &mn10300_frame_unwind);
+ set_gdbarch_dummy_id (gdbarch, mn10300_dummy_id);
+ set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
+ set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
}
-/* Function: push_arguments
- Setup arguments for a call to the target. Arguments go in
- order on the stack. */
+/* Function: push_dummy_call
+ *
+ * Set up machine state for a target call, including
+ * function arguments, stack, return address, etc.
+ *
+ */
static CORE_ADDR
-mn10300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
+mn10300_push_dummy_call (struct gdbarch *gdbarch,
+ struct value *target_func,
+ struct regcache *regcache,
+ CORE_ADDR bp_addr,
+ int nargs, struct value **args,
+ CORE_ADDR sp,
+ int struct_return,
+ CORE_ADDR struct_addr)
{
- int argnum = 0;
- int len = 0;
+ enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
+ const int push_size = register_size (gdbarch, E_PC_REGNUM);
+ int regs_used;
+ int len, arg_len;
int stack_offset = 0;
- int regsused = struct_return ? 1 : 0;
+ int argnum;
+ char *val, valbuf[MAX_REGISTER_SIZE];
/* This should be a nop, but align the stack just in case something
went wrong. Stacks are four byte aligned on the mn10300. */
XXX This doesn't appear to handle pass-by-invisible reference
arguments. */
- for (argnum = 0; argnum < nargs; argnum++)
+ regs_used = struct_return ? 1 : 0;
+ for (len = 0, argnum = 0; argnum < nargs; argnum++)
{
- int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
-
- while (regsused < 2 && arg_length > 0)
+ arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
+ while (regs_used < 2 && arg_len > 0)
{
- regsused++;
- arg_length -= 4;
+ regs_used++;
+ arg_len -= push_size;
}
- len += arg_length;
+ len += arg_len;
}
/* Allocate stack space. */
sp -= len;
- regsused = struct_return ? 1 : 0;
- /* Push all arguments onto the stack. */
- for (argnum = 0; argnum < nargs; argnum++)
+ if (struct_return)
{
- int len;
- char *val;
+ regs_used = 1;
+ regcache_cooked_write_unsigned (regcache, E_D0_REGNUM, struct_addr);
+ }
+ else
+ regs_used = 0;
- /* XXX Check this. What about UNIONS? */
- if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
- && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
+ /* Push all arguments onto the stack. */
+ for (argnum = 0; argnum < nargs; argnum++)
+ {
+ /* FIXME what about structs? Unions? */
+ if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
+ && TYPE_LENGTH (value_type (*args)) > 8)
{
- /* XXX Wrong, we want a pointer to this argument. */
- len = TYPE_LENGTH (VALUE_TYPE (*args));
- val = (char *) VALUE_CONTENTS (*args);
+ /* Change to pointer-to-type. */
+ arg_len = push_size;
+ store_unsigned_integer (valbuf, push_size, byte_order,
+ value_address (*args));
+ val = &valbuf[0];
}
else
{
- len = TYPE_LENGTH (VALUE_TYPE (*args));
- val = (char *) VALUE_CONTENTS (*args);
+ arg_len = TYPE_LENGTH (value_type (*args));
+ val = (char *) value_contents (*args);
}
- while (regsused < 2 && len > 0)
+ while (regs_used < 2 && arg_len > 0)
{
- write_register (regsused, extract_unsigned_integer (val, 4));
- val += 4;
- len -= 4;
- regsused++;
+ regcache_cooked_write_unsigned (regcache, regs_used,
+ extract_unsigned_integer (val, push_size, byte_order));
+ val += push_size;
+ arg_len -= push_size;
+ regs_used++;
}
- while (len > 0)
+ while (arg_len > 0)
{
- write_memory (sp + stack_offset, val, 4);
- len -= 4;
- val += 4;
- stack_offset += 4;
+ write_memory (sp + stack_offset, val, push_size);
+ arg_len -= push_size;
+ val += push_size;
+ stack_offset += push_size;
}
args++;
/* Make space for the flushback area. */
sp -= 8;
- return sp;
-}
-
-/* Function: push_return_address (pc)
- Set up the return address for the inferior function call.
- Needed for targets where we don't actually execute a JSR/BSR instruction */
-static CORE_ADDR
-mn10300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
-{
- unsigned char buf[4];
-
- store_unsigned_integer (buf, 4, entry_point_address ());
- write_memory (sp - 4, buf, 4);
- return sp - 4;
-}
-
-/* Function: store_struct_return (addr,sp)
- Store the structure value return address for an inferior function
- call. */
-
-static void
-mn10300_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
-{
- /* The structure return address is passed as the first argument. */
- write_register (0, addr);
-}
-
-/* Function: frame_saved_pc
- Find the caller of this frame. We do this by seeing if RP_REGNUM
- is saved in the stack anywhere, otherwise we get it from the
- registers. If the inner frame is a dummy frame, return its PC
- instead of RP, because that's where "caller" of the dummy-frame
- will be found. */
-
-static CORE_ADDR
-mn10300_frame_saved_pc (struct frame_info *fi)
-{
- int adjust = saved_regs_size (fi);
-
- return (read_memory_integer (get_frame_base (fi) + adjust,
- DEPRECATED_REGISTER_SIZE));
-}
-
-/* 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().
-
- Note that when we are called for the last frame (currently active frame),
- that get_frame_pc (fi) and fi->frame will already be setup. However, fi->frame will
- be valid only if this routine uses FP. For previous frames, fi-frame will
- always be correct. mn10300_analyze_prologue will fix fi->frame if
- it's not valid.
-
- We can be called with the PC in the call dummy under two
- circumstances. First, during normal backtracing, second, while
- figuring out the frame pointer just prior to calling the target
- function (see call_function_by_hand). */
-
-static void
-mn10300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
-{
- if (get_next_frame (fi))
- deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
-
- frame_saved_regs_zalloc (fi);
- frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
-
- get_frame_extra_info (fi)->status = 0;
- get_frame_extra_info (fi)->stack_size = 0;
-
- mn10300_analyze_prologue (fi, 0);
-}
-
-
-/* This function's job is handled by init_extra_frame_info. */
-static void
-mn10300_frame_init_saved_regs (struct frame_info *frame)
-{
-}
-
-
-/* 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. */
-
-static void
-mn10300_virtual_frame_pointer (CORE_ADDR pc,
- int *reg,
- LONGEST *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 (get_frame_extra_info (dummy)->status & MY_FRAME_IN_SP)
- {
- *reg = SP_REGNUM;
- *offset = -(get_frame_extra_info (dummy)->stack_size);
- }
- else
- {
- *reg = A3_REGNUM;
- *offset = 0;
- }
-}
-
-static int
-mn10300_reg_struct_has_addr (int gcc_p, struct type *type)
-{
- return (TYPE_LENGTH (type) > 8);
-}
-
-static struct type *
-mn10300_register_virtual_type (int reg)
-{
- return builtin_type_int;
-}
-
-static int
-mn10300_register_byte (int reg)
-{
- return (reg * 4);
-}
-
-static int
-mn10300_register_virtual_size (int reg)
-{
- return 4;
-}
+ /* Push the return address that contains the magic breakpoint. */
+ sp -= 4;
+ write_memory_unsigned_integer (sp, push_size, byte_order, bp_addr);
+
+ /* The CPU also writes the return address always into the
+ MDR register on "call". */
+ regcache_cooked_write_unsigned (regcache, E_MDR_REGNUM, bp_addr);
+
+ /* Update $sp. */
+ regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
+
+ /* On the mn10300, it's possible to move some of the stack adjustment
+ and saving of the caller-save registers out of the prologue and
+ into the call sites. (When using gcc, this optimization can
+ occur when using the -mrelax switch.) If this occurs, the dwarf2
+ info will reflect this fact. We can test to see if this is the
+ case by creating a new frame using the current stack pointer and
+ the address of the function that we're about to call. We then
+ unwind SP and see if it's different than the SP of our newly
+ created frame. If the SP values are the same, the caller is not
+ expected to allocate any additional stack. On the other hand, if
+ the SP values are different, the difference determines the
+ additional stack that must be allocated.
+
+ Note that we don't update the return value though because that's
+ the value of the stack just after pushing the arguments, but prior
+ to performing the call. This value is needed in order to
+ construct the frame ID of the dummy call. */
+ {
+ CORE_ADDR func_addr = find_function_addr (target_func, NULL);
+ CORE_ADDR unwound_sp
+ = mn10300_unwind_sp (gdbarch, create_new_frame (sp, func_addr));
+ if (sp != unwound_sp)
+ regcache_cooked_write_unsigned (regcache, E_SP_REGNUM,
+ sp - (unwound_sp - sp));
+ }
-static int
-mn10300_register_raw_size (int reg)
-{
- return 4;
+ return sp;
}
/* If DWARF2 is a register number appearing in Dwarf2 debug info, then
to work with the existing GDB, neither of them can change. So we
just have to cope. */
static int
-mn10300_dwarf2_reg_to_regnum (int dwarf2)
+mn10300_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2)
{
- /* This table is supposed to be shaped like the REGISTER_NAMES
+ /* This table is supposed to be shaped like the gdbarch_register_name
initializer in gcc/config/mn10300/mn10300.h. Registers which
appear in GCC's numbering, but have no counterpart in GDB's
world, are marked with a -1. */
static int dwarf2_to_gdb[] = {
0, 1, 2, 3, 4, 5, 6, 7, -1, 8,
- 15, 16, 17, 18, 19, 20, 21, 22
+ 15, 16, 17, 18, 19, 20, 21, 22,
+ 32, 33, 34, 35, 36, 37, 38, 39,
+ 40, 41, 42, 43, 44, 45, 46, 47,
+ 48, 49, 50, 51, 52, 53, 54, 55,
+ 56, 57, 58, 59, 60, 61, 62, 63,
+ 9, 11
};
- int gdb;
if (dwarf2 < 0
- || dwarf2 >= (sizeof (dwarf2_to_gdb) / sizeof (dwarf2_to_gdb[0]))
- || dwarf2_to_gdb[dwarf2] == -1)
- internal_error (__FILE__, __LINE__,
- "bogus register number in debug info: %d", dwarf2);
-
- return dwarf2_to_gdb[dwarf2];
-}
-
-static void
-mn10300_print_register (const char *name, int regnum, int reg_width)
-{
- char raw_buffer[MAX_REGISTER_SIZE];
-
- if (reg_width)
- printf_filtered ("%*s: ", reg_width, name);
- else
- printf_filtered ("%s: ", name);
-
- /* Get the data */
- if (!frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
- {
- printf_filtered ("[invalid]");
- return;
- }
- else
- {
- int byte;
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- {
- for (byte = register_size (current_gdbarch, regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
- byte < register_size (current_gdbarch, regnum);
- byte++)
- printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
- }
- else
- {
- for (byte = DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum) - 1;
- byte >= 0;
- byte--)
- printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
- }
- }
-}
-
-static void
-mn10300_do_registers_info (int regnum, int fpregs)
-{
- if (regnum >= 0)
- {
- const char *name = REGISTER_NAME (regnum);
- if (name == NULL || name[0] == '\0')
- error ("Not a valid register for the current processor type");
- mn10300_print_register (name, regnum, 0);
- printf_filtered ("\n");
- }
- else
+ || dwarf2 >= ARRAY_SIZE (dwarf2_to_gdb))
{
- /* print registers in an array 4x8 */
- int r;
- int reg;
- const int nr_in_row = 4;
- const int reg_width = 4;
- for (r = 0; r < NUM_REGS; r += nr_in_row)
- {
- int c;
- int printing = 0;
- int padding = 0;
- for (c = r; c < r + nr_in_row; c++)
- {
- const char *name = REGISTER_NAME (c);
- if (name != NULL && *name != '\0')
- {
- printing = 1;
- while (padding > 0)
- {
- printf_filtered (" ");
- padding--;
- }
- mn10300_print_register (name, c, reg_width);
- printf_filtered (" ");
- }
- else
- {
- padding += (reg_width + 2 + 8 + 1);
- }
- }
- if (printing)
- printf_filtered ("\n");
- }
+ warning (_("Bogus register number in debug info: %d"), dwarf2);
+ return -1;
}
-}
-
-static CORE_ADDR
-mn10300_read_fp (void)
-{
- /* That's right, we're using the stack pointer as our frame pointer. */
- gdb_assert (SP_REGNUM >= 0);
- return read_register (SP_REGNUM);
-}
-/* Dump out the mn10300 speciic architecture information. */
-
-static void
-mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
-{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
- tdep->am33_mode);
+ return dwarf2_to_gdb[dwarf2];
}
static struct gdbarch *
struct gdbarch_list *arches)
{
struct gdbarch *gdbarch;
- struct gdbarch_tdep *tdep = NULL;
- int am33_mode;
- gdbarch_register_name_ftype *register_name;
- int mach;
+ struct gdbarch_tdep *tdep;
int num_regs;
arches = gdbarch_list_lookup_by_info (arches, &info);
if (arches != NULL)
return arches->gdbarch;
+
tdep = xmalloc (sizeof (struct gdbarch_tdep));
gdbarch = gdbarch_alloc (&info, tdep);
- if (info.bfd_arch_info != NULL
- && info.bfd_arch_info->arch == bfd_arch_mn10300)
- mach = info.bfd_arch_info->mach;
- else
- mach = 0;
- switch (mach)
+ switch (info.bfd_arch_info->mach)
{
case 0:
case bfd_mach_mn10300:
- am33_mode = 0;
- register_name = mn10300_generic_register_name;
+ set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
+ tdep->am33_mode = 0;
num_regs = 32;
break;
case bfd_mach_am33:
- am33_mode = 1;
- register_name = am33_register_name;
+ set_gdbarch_register_name (gdbarch, am33_register_name);
+ tdep->am33_mode = 1;
num_regs = 32;
break;
+ case bfd_mach_am33_2:
+ set_gdbarch_register_name (gdbarch, am33_2_register_name);
+ tdep->am33_mode = 2;
+ num_regs = 64;
+ set_gdbarch_fp0_regnum (gdbarch, 32);
+ break;
default:
internal_error (__FILE__, __LINE__,
- "mn10300_gdbarch_init: Unknown mn10300 variant");
- return NULL; /* keep GCC happy. */
+ _("mn10300_gdbarch_init: Unknown mn10300 variant"));
+ break;
}
+ /* By default, chars are unsigned. */
+ set_gdbarch_char_signed (gdbarch, 0);
+
/* Registers. */
set_gdbarch_num_regs (gdbarch, num_regs);
- set_gdbarch_register_name (gdbarch, register_name);
- set_gdbarch_deprecated_register_size (gdbarch, 4);
- set_gdbarch_deprecated_register_bytes (gdbarch, num_regs * gdbarch_deprecated_register_size (gdbarch));
- set_gdbarch_deprecated_register_raw_size (gdbarch, mn10300_register_raw_size);
- set_gdbarch_deprecated_register_byte (gdbarch, mn10300_register_byte);
- set_gdbarch_deprecated_register_virtual_size (gdbarch, mn10300_register_virtual_size);
- set_gdbarch_deprecated_register_virtual_type (gdbarch, mn10300_register_virtual_type);
+ set_gdbarch_register_type (gdbarch, mn10300_register_type);
+ set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
+ set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
+ set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
+ set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
+ set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
set_gdbarch_dwarf2_reg_to_regnum (gdbarch, mn10300_dwarf2_reg_to_regnum);
- set_gdbarch_deprecated_do_registers_info (gdbarch, mn10300_do_registers_info);
- set_gdbarch_sp_regnum (gdbarch, 8);
- set_gdbarch_pc_regnum (gdbarch, 9);
- set_gdbarch_deprecated_fp_regnum (gdbarch, 31);
- set_gdbarch_virtual_frame_pointer (gdbarch, mn10300_virtual_frame_pointer);
+ /* Stack unwinding. */
+ set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
/* Breakpoints. */
set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
+ /* decr_pc_after_break? */
+ /* Disassembly. */
+ set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
- /* Stack unwinding. */
- set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
- set_gdbarch_deprecated_saved_pc_after_call (gdbarch, mn10300_saved_pc_after_call);
- set_gdbarch_deprecated_init_extra_frame_info (gdbarch, mn10300_init_extra_frame_info);
- set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, mn10300_frame_init_saved_regs);
- set_gdbarch_deprecated_frame_chain (gdbarch, mn10300_frame_chain);
- set_gdbarch_deprecated_frame_saved_pc (gdbarch, mn10300_frame_saved_pc);
+ /* Stage 2 */
set_gdbarch_return_value (gdbarch, mn10300_return_value);
- set_gdbarch_deprecated_store_struct_return (gdbarch, mn10300_store_struct_return);
- set_gdbarch_deprecated_pop_frame (gdbarch, mn10300_pop_frame);
- set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
- /* That's right, we're using the stack pointer as our frame pointer. */
- set_gdbarch_deprecated_target_read_fp (gdbarch, mn10300_read_fp);
-
- /* Calling functions in the inferior from GDB. */
- set_gdbarch_deprecated_push_arguments (gdbarch, mn10300_push_arguments);
- set_gdbarch_deprecated_reg_struct_has_addr
- (gdbarch, mn10300_reg_struct_has_addr);
- set_gdbarch_deprecated_push_return_address (gdbarch, mn10300_push_return_address);
+
+ /* Stage 3 -- get target calls working. */
+ set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);
+ /* set_gdbarch_return_value (store, extract) */
- tdep->am33_mode = am33_mode;
- /* Should be using push_dummy_call. */
- set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
+ mn10300_frame_unwind_init (gdbarch);
- set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
+ /* Hook in ABI-specific overrides, if they have been registered. */
+ gdbarch_init_osabi (info, gdbarch);
return gdbarch;
}
+/* Dump out the mn10300 specific architecture information. */
+
+static void
+mn10300_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
+{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
+ tdep->am33_mode);
+}
+
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern initialize_file_ftype _initialize_mn10300_tdep;
+
void
_initialize_mn10300_tdep (void)
{
-/* printf("_initialize_mn10300_tdep\n"); */
gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
}
+
projects / external / binutils.git / blobdiff