/* 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"
+
+#include "mn10300-tdep.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);
+/* The am33-2 has 64 registers. */
+#define MN10300_MAX_NUM_REGS 64
-/* mn10300 private data */
-struct gdbarch_tdep
+/* This structure holds the results of a prologue analysis. */
+struct mn10300_prologue
{
- int am33_mode;
-#define AM33_MODE (gdbarch_tdep (current_gdbarch)->am33_mode)
+ /* The architecture for which we generated this prologue info. */
+ struct gdbarch *gdbarch;
+
+ /* 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];
};
-/* Additional info used by the frame */
-struct frame_extra_info
- {
- int status;
- int stack_size;
- };
+/* Compute the alignment required by a type. */
+
+static int
+mn10300_type_align (struct type *type)
+{
+ int i, align = 1;
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_INT:
+ case TYPE_CODE_ENUM:
+ case TYPE_CODE_SET:
+ case TYPE_CODE_RANGE:
+ case TYPE_CODE_CHAR:
+ case TYPE_CODE_BOOL:
+ case TYPE_CODE_FLT:
+ case TYPE_CODE_PTR:
+ case TYPE_CODE_REF:
+ return TYPE_LENGTH (type);
+
+ case TYPE_CODE_COMPLEX:
+ return TYPE_LENGTH (type) / 2;
+
+ case TYPE_CODE_STRUCT:
+ case TYPE_CODE_UNION:
+ for (i = 0; i < TYPE_NFIELDS (type); i++)
+ {
+ int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
+ while (align < falign)
+ align <<= 1;
+ }
+ return align;
+
+ case TYPE_CODE_ARRAY:
+ /* HACK! Structures containing arrays, even small ones, are not
+ elligible for returning in registers. */
+ return 256;
+
+ case TYPE_CODE_TYPEDEF:
+ return mn10300_type_align (check_typedef (type));
+
+ default:
+ internal_error (__FILE__, __LINE__, _("bad switch"));
+ }
+}
+
+/* Should call_function allocate stack space for a struct return? */
+static int
+mn10300_use_struct_convention (struct type *type)
+{
+ /* Structures bigger than a pair of words can't be returned in
+ registers. */
+ if (TYPE_LENGTH (type) > 8)
+ return 1;
+
+ switch (TYPE_CODE (type))
+ {
+ case TYPE_CODE_STRUCT:
+ case TYPE_CODE_UNION:
+ /* Structures with a single field are handled as the field
+ itself. */
+ if (TYPE_NFIELDS (type) == 1)
+ return mn10300_use_struct_convention (TYPE_FIELD_TYPE (type, 0));
+
+ /* Structures with word or double-word size are passed in memory, as
+ long as they require at least word alignment. */
+ if (mn10300_type_align (type) >= 4)
+ return 0;
+
+ return 1;
+
+ /* Arrays are addressable, so they're never returned in
+ registers. This condition can only hold when the array is
+ the only field of a struct or union. */
+ case TYPE_CODE_ARRAY:
+ return 1;
+
+ case TYPE_CODE_TYPEDEF:
+ return mn10300_use_struct_convention (check_typedef (type));
+
+ default:
+ return 0;
+ }
+}
+
+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,
+ and copy it into READBUF. If WRITEBUF is non-zero, write the value
+ from WRITEBUF into REGCACHE. */
+
+static enum return_value_convention
+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;
+
+ if (readbuf)
+ mn10300_extract_return_value (gdbarch, type, regcache, readbuf);
+ if (writebuf)
+ mn10300_store_return_value (gdbarch, type, regcache, writebuf);
+
+ return RETURN_VALUE_REGISTER_CONVENTION;
+}
static char *
register_name (int reg, char **regs, long sizeof_regs)
}
static const char *
-mn10300_generic_register_name (int reg)
+mn10300_generic_register_name (struct gdbarch *gdbarch, int reg)
{
static char *regs[] =
{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
static const char *
-am33_register_name (int reg)
+am33_register_name (struct gdbarch *gdbarch, int reg)
{
static char *regs[] =
{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
};
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 type *type, char *regbuf, char *valbuf)
+static const char *
+am33_2_register_name (struct gdbarch *gdbarch, int reg)
{
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
- memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (4), TYPE_LENGTH (type));
- else
- memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (0), TYPE_LENGTH (type));
+ 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 void
-mn10300_store_return_value (struct type *type, char *valbuf)
+static struct type *
+mn10300_register_type (struct gdbarch *gdbarch, int reg)
{
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
- deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (4), valbuf,
- TYPE_LENGTH (type));
- else
- deprecated_write_register_bytes (DEPRECATED_REGISTER_BYTE (0), valbuf,
- TYPE_LENGTH (type));
+ return builtin_type (gdbarch)->builtin_int;
}
-static struct frame_info *analyze_dummy_frame (CORE_ADDR, CORE_ADDR);
-static struct frame_info *
-analyze_dummy_frame (CORE_ADDR pc, CORE_ADDR frame)
+static CORE_ADDR
+mn10300_read_pc (struct regcache *regcache)
{
- 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;
+ ULONGEST val;
+ regcache_cooked_read_unsigned (regcache, E_PC_REGNUM, &val);
+ return val;
}
-/* 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? */
-static int
-mn10300_use_struct_convention (int gcc_p, struct type *type)
+static void
+mn10300_write_pc (struct regcache *regcache, CORE_ADDR val)
{
- return (TYPE_NFIELDS (type) > 1 || TYPE_LENGTH (type) > 8);
+ regcache_cooked_write_unsigned (regcache, E_PC_REGNUM, val);
}
/* The breakpoint instruction must be the same size as the smallest
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;
-/* The main purpose of this file is dealing with prologues to extract
- information about stack frames and saved registers.
+ /* movm [regs], sp */
+ if (instr[0] == 0xcf)
+ {
+ gdb_byte save_mask;
- 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!):
+ save_mask = instr[1];
- + 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 ((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);
+ }
- + If we use any of the callee-saved registers, save them now.
-
- movm [some callee-saved registers],(sp)
+ pc += 2;
+ after_last_frame_setup_insn = pc;
+ }
+ /* mov sp, aN */
+ else if ((instr[0] & 0xfc) == 0x3c)
+ {
+ int aN = instr[0] & 0x03;
- + If we have any floating-point registers to save:
+ regs[E_A0_REGNUM + aN] = regs[E_SP_REGNUM];
- - 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.
+ 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;
- add -SIZE, sp
+ regs[E_A0_REGNUM + aN] = regs[E_A0_REGNUM + aM];
- - Save the floating-point registers. We have two possible
- strategies:
+ 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;
- . Save them at fixed offset from the SP:
+ regs[E_D0_REGNUM + dN] = regs[E_D0_REGNUM + dM];
- fmov fsN,(OFFSETN,sp)
- fmov fsM,(OFFSETM,sp)
- ...
+ 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;
- Note that, if OFFSETN happens to be zero, you'll get the
- different opcode: fmov fsN,(sp)
+ regs[E_D0_REGNUM + dN] = regs[E_A0_REGNUM + aM];
- . Or, set a0 to the start of the save area, and then use
- post-increment addressing to save the FP registers.
+ 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;
- mov sp, a0
- add SIZE, a0
- fmov fsN,(a0+)
- fmov fsM,(a0+)
- ...
+ regs[E_A0_REGNUM + aN] = regs[E_D0_REGNUM + dM];
- + If the function needs a frame pointer, we set it here.
+ pc += 2;
+ }
+ /* add imm8, SP */
+ else if (instr[0] == 0xf8 && instr[1] == 0xfe)
+ {
+ gdb_byte buf[1];
+ LONGEST imm8;
- mov sp, a3
- + 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
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
- 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. */
+ imm8 = extract_signed_integer (buf, 1, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm8);
-/* Analyze the prologue to determine where registers are saved,
- the end of the prologue, etc etc. Return the end of the prologue
- scanned.
+ 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;
- We store into FI (if non-null) several tidbits of information:
+ status = target_read_memory (pc + 2, buf, 2);
+ 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.
+ imm16 = extract_signed_integer (buf, 2, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm16);
- * fsr -- Addresses of registers saved in the stack by this frame.
+ 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 -- A (relatively) generic status indicator. It's a bitmask
- with the following bits:
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- 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.
- MY_FRAME_IN_FP: The base of the current frame is in the
- frame pointer register ($a3).
+ imm32 = extract_signed_integer (buf, 4, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm32);
- 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. */
+ 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;
-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;
- }
+ aN = instr[0] & 0x03;
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
- /* 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;
- }
+ regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
+ imm8);
- /* 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;
+ pc += 2;
+ }
+ /* add imm16, aN */
+ else if (instr[0] == 0xfa && (instr[1] & 0xfc) == 0xd0)
+ {
+ int aN;
+ LONGEST imm16;
+ gdb_byte buf[2];
- /* 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 = read_memory_nobpt (pc, buf, 2);
- if (status != 0)
- return pc;
+ aN = instr[1] & 0x03;
-#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.
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- 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);
- }
- /* 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
+ imm16 = extract_signed_integer (buf, 2, byte_order);
- /* Figure out where to stop scanning. */
- stop = fi ? pc : func_end;
+ regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
+ imm16);
- /* Don't walk off the end of the function. */
- stop = stop > func_end ? func_end : stop;
+ pc += 4;
+ }
+ /* add imm32, aN */
+ else if (instr[0] == 0xfc && (instr[1] & 0xfc) == 0xd0)
+ {
+ int aN;
+ LONGEST imm32;
+ gdb_byte buf[4];
- /* Start scanning on the first instruction of this function. */
- addr = func_addr;
+ aN = instr[1] & 0x03;
- /* Suck in two bytes. */
- status = read_memory_nobpt (addr, buf, 2);
- if (status != 0)
- {
- fix_frame_pointer (fi, 0);
- return addr;
- }
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- /* 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;
- }
+ imm32 = extract_signed_integer (buf, 2, byte_order);
- /* Now look for movm [regs],sp, which saves the callee saved registers.
+ 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];
- 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 = read_memory_nobpt (addr + 1, buf, 1);
- movm_args = *buf;
+ Y = (instr[1] & 0x02) >> 1;
- addr += 2;
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
- /* 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 ());
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
+ pv_area_store (stack, regs[translate_rreg (rN)], 4,
+ regs[E_FS0_REGNUM + fsM]);
- /* Get the next two bytes so the prologue scan can continue. */
- status = read_memory_nobpt (addr, buf, 2);
- if (status != 0)
+ pc += 3;
+ }
+ /* fmov fsM, (sp) */
+ else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x34)
{
- /* 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;
+ gdb_byte buf[1];
- /* 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, 1);
+ 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;
+ fsM = (Y << 4) | sM;
- /* 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);
+ pv_area_store (stack, regs[E_SP_REGNUM], 4,
+ regs[E_FS0_REGNUM + fsM]);
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
+ pc += 3;
}
-
- /* Get two more bytes so scanning can continue. */
- status = read_memory_nobpt (addr, buf, 2);
- if (status != 0)
+ /* fmov fsM, (rN, rI) */
+ else if (instr[0] == 0xfb && instr[1] == 0x37)
{
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ int fsM, sM, Z, rN, rI;
+ gdb_byte buf[2];
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
- }
- /* Next we should allocate the local frame. No more prologue insns
- are found after allocating the local frame.
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- Search for add imm8,sp (0xf8feXX)
- or add imm16,sp (0xfafeXXXX)
- or add imm32,sp (0xfcfeXXXXXXXX).
+ rI = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ sM = (buf[1] & 0xf0) >> 4;
+ Z = (buf[1] & 0x02) >> 1;
+ fsM = (Z << 4) | sM;
- If none of the above was found, then this prologue has no
- additional stack. */
+ pv_area_store (stack,
+ pv_add (regs[translate_rreg (rN)],
+ regs[translate_rreg (rI)]),
+ 4, regs[E_FS0_REGNUM + fsM]);
- status = read_memory_nobpt (addr, buf, 2);
- if (status != 0)
- {
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ 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];
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
+ Y = (instr[1] & 0x02) >> 1;
- 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;
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- if (imm_size != 0)
- {
- /* Suck in imm_size more bytes, they'll hold the size of the
- current frame. */
- status = read_memory_nobpt (addr + 2, buf, imm_size);
- if (status != 0)
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d8 = extract_signed_integer (&buf[1], 1, byte_order);
+
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d8),
+ 4, regs[E_FS0_REGNUM + fsM]);
+
+ pc += 4;
+ }
+ /* fmov fsM, (d24, rN) */
+ else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x30)
{
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ int fsM, sM, Y, rN;
+ LONGEST d24;
+ gdb_byte buf[4];
+
+ Y = (instr[1] & 0x02) >> 1;
+
+ 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;
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d24 = extract_signed_integer (&buf[1], 3, byte_order);
+
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d24),
+ 4, regs[E_FS0_REGNUM + fsM]);
+
+ 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];
- /* 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;
+ Y = (instr[1] & 0x02) >> 1;
- /* We just consumed 2 + imm_size bytes. */
- addr += 2 + imm_size;
+ status = target_read_memory (pc + 2, buf, 5);
+ if (status != 0)
+ break;
- /* 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);
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d32 = extract_signed_integer (&buf[1], 4, byte_order);
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d32),
+ 4, regs[E_FS0_REGNUM + fsM]);
- /* 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);
+ 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];
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
-}
+ Y = (instr[1] & 0x02) >> 1;
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
-/* 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;
-}
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d8 = extract_signed_integer (&buf[1], 1, byte_order);
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d8),
+ 4, regs[E_FS0_REGNUM + fsM]);
-/* Function: frame_chain
- Figure out and return the caller's frame pointer given current
- frame_info struct.
+ 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];
- 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? */
+ Y = (instr[1] & 0x02) >> 1;
-static CORE_ADDR
-mn10300_frame_chain (struct frame_info *fi)
-{
- 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);
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
- if (get_frame_extra_info (fi)->status & NO_MORE_FRAMES)
- return 0;
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d24 = extract_signed_integer (&buf[1], 3, byte_order);
- /* Now that we've analyzed our prologue, determine the frame
- pointer for our caller.
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d24),
+ 4, regs[E_FS0_REGNUM + fsM]);
- If our caller has a frame pointer, then we need to
- find the entry value of $a3 to our function.
+ 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];
- If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
- location pointed to by fsr.regs[A3_REGNUM].
+ Y = (instr[1] & 0x02) >> 1;
- Else it's still in $a3.
+ status = target_read_memory (pc + 2, buf, 5);
+ if (status != 0)
+ break;
- If our caller does not have a frame pointer, then his
- frame base is fi->frame + -caller's stack size. */
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d32 = extract_signed_integer (&buf[1], 4, byte_order);
- /* 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));
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d32),
+ 4, regs[E_FS0_REGNUM + fsM]);
- if (get_frame_extra_info (dummy)->status & MY_FRAME_IN_FP)
- {
- /* 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);
- }
- else
- {
- int adjust = saved_regs_size (fi);
+ 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];
- /* 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;
- }
-}
+ Y = (instr[1] & 0x02) >> 1;
-/* Function: skip_prologue
- Return the address of the first inst past the prologue of the function. */
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
-static CORE_ADDR
-mn10300_skip_prologue (CORE_ADDR pc)
-{
- /* We used to check the debug symbols, but that can lose if
- we have a null prologue. */
- return mn10300_analyze_prologue (NULL, pc);
-}
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
-/* 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)
-{
- int regnum;
+ rN_regnum = translate_rreg (rN);
- write_register (PC_REGNUM, DEPRECATED_FRAME_SAVED_PC (frame));
+ pv_area_store (stack, regs[rN_regnum], 4,
+ regs[E_FS0_REGNUM + fsM]);
+ regs[rN_regnum] = pv_add_constant (regs[rN_regnum], 4);
- /* Restore any saved registers. */
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (deprecated_get_frame_saved_regs (frame)[regnum] != 0)
- {
- ULONGEST value;
+ pc += 3;
+ }
+ /* fmov fsM, (rN+, imm8) */
+ else if (instr[0] == 0xfb && (instr[1] & 0xfd) == 0x31)
+ {
+ int fsM, sM, Y, rN, rN_regnum;
+ LONGEST imm8;
+ gdb_byte buf[2];
- value = read_memory_unsigned_integer (deprecated_get_frame_saved_regs (frame)[regnum],
- DEPRECATED_REGISTER_RAW_SIZE (regnum));
- write_register (regnum, value);
- }
+ Y = (instr[1] & 0x02) >> 1;
- /* Actually cut back the stack. */
- write_register (SP_REGNUM, get_frame_base (frame));
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- /* Don't we need to set the PC?!? XXX FIXME. */
-}
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ imm8 = extract_signed_integer (&buf[1], 1, byte_order);
-/* 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)
-{
- /* This function checks for and handles generic dummy frames, and
- calls back to our function for ordinary frames. */
- generic_pop_current_frame (mn10300_pop_frame_regular);
+ rN_regnum = translate_rreg (rN);
- /* Throw away any cached frame information. */
- flush_cached_frames ();
-}
+ pv_area_store (stack, regs[rN_regnum], 4, regs[E_FS0_REGNUM + fsM]);
+ regs[rN_regnum] = pv_add_constant (regs[rN_regnum], imm8);
-/* Function: push_arguments
- Setup arguments for a call to the target. Arguments go in
- order on the stack. */
+ 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];
-static CORE_ADDR
-mn10300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
- int struct_return, CORE_ADDR struct_addr)
-{
- int argnum = 0;
- int len = 0;
- int stack_offset = 0;
- int regsused = struct_return ? 1 : 0;
+ Y = (instr[1] & 0x02) >> 1;
- /* This should be a nop, but align the stack just in case something
- went wrong. Stacks are four byte aligned on the mn10300. */
- sp &= ~3;
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- /* Now make space on the stack for the args.
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ imm24 = extract_signed_integer (&buf[1], 3, byte_order);
- XXX This doesn't appear to handle pass-by-invisible reference
- arguments. */
- for (argnum = 0; argnum < nargs; argnum++)
- {
- int arg_length = (TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3;
+ 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);
- while (regsused < 2 && arg_length > 0)
+ pc += 6;
+ }
+ /* fmov fsM, (rN+, imm32) */
+ else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x31)
{
- regsused++;
- arg_length -= 4;
+ 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;
+
+ 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;
}
- len += arg_length;
- }
+ /* mov imm8, aN */
+ else if ((instr[0] & 0xf0) == 0x90)
+ {
+ int aN = instr[0] & 0x03;
+ LONGEST imm8;
- /* Allocate stack space. */
- sp -= len;
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
- regsused = struct_return ? 1 : 0;
- /* Push all arguments onto the stack. */
- for (argnum = 0; argnum < nargs; argnum++)
- {
- int len;
- char *val;
+ 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;
- /* XXX Check this. What about 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);
+ status = target_read_memory (pc + 1, buf, 2);
+ if (status != 0)
+ break;
+
+ imm16 = extract_signed_integer (buf, 2, byte_order);
+ regs[E_A0_REGNUM + aN] = pv_constant (imm16);
+ pc += 3;
}
- else
- {
- len = TYPE_LENGTH (VALUE_TYPE (*args));
- val = (char *) VALUE_CONTENTS (*args);
+ /* mov imm32, aN */
+ else if (instr[0] == 0xfc && ((instr[1] & 0xfc) == 0xdc))
+ {
+ int aN = instr[1] & 0x03;
+ 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_A0_REGNUM + aN] = pv_constant (imm32);
+ pc += 6;
}
+ /* mov imm8, dN */
+ else if ((instr[0] & 0xf0) == 0x80)
+ {
+ int dN = instr[0] & 0x03;
+ LONGEST imm8;
- while (regsused < 2 && len > 0)
- {
- write_register (regsused, extract_unsigned_integer (val, 4));
- val += 4;
- len -= 4;
- regsused++;
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
+
+ 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;
- while (len > 0)
- {
- write_memory (sp + stack_offset, val, 4);
- len -= 4;
- val += 4;
- stack_offset += 4;
+ status = target_read_memory (pc + 1, buf, 2);
+ if (status != 0)
+ break;
+
+ 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;
- args++;
- }
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- /* Make space for the flushback area. */
- sp -= 8;
- return sp;
-}
+ 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;
+ }
+ }
-/* 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 */
+ /* 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;
-static CORE_ADDR
-mn10300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
-{
- unsigned char buf[4];
+ /* 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;
+ }
- store_unsigned_integer (buf, 4, entry_point_address ());
- write_memory (sp - 4, buf, 4);
- return sp - 4;
-}
+ /* Record where all the registers were saved. */
+ pv_area_scan (stack, check_for_saved, (void *) result);
-/* Function: store_struct_return (addr,sp)
- Store the structure value return address for an inferior function
- call. */
+ result->prologue_end = after_last_frame_setup_insn;
-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);
+ do_cleanups (back_to);
}
-/* 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. */
+/* Function: skip_prologue
+ Return the address of the first inst past the prologue of the function. */
static CORE_ADDR
-mn10300_frame_saved_pc (struct frame_info *fi)
+mn10300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
- 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().
+ const char *name;
+ CORE_ADDR func_addr, func_end;
+ struct mn10300_prologue p;
- 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.
+ /* Try to find the extent of the function that contains PC. */
+ if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
+ return pc;
- 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). */
+ mn10300_analyze_prologue (gdbarch, pc, func_end, &p);
+ return p.prologue_end;
+}
-static void
-mn10300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
+/* 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 (get_next_frame (fi))
- deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
+ if (!*this_prologue_cache)
+ {
+ CORE_ADDR func_start, stop_addr;
- frame_saved_regs_zalloc (fi);
- frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
+ *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct mn10300_prologue);
- get_frame_extra_info (fi)->status = 0;
- get_frame_extra_info (fi)->stack_size = 0;
+ func_start = get_frame_func (this_frame);
+ stop_addr = get_frame_pc (this_frame);
- mn10300_analyze_prologue (fi, 0);
-}
+ /* 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;
+ mn10300_analyze_prologue (get_frame_arch (this_frame),
+ func_start, stop_addr, *this_prologue_cache);
+ }
-/* This function's job is handled by init_extra_frame_info. */
-static void
-mn10300_frame_init_saved_regs (struct frame_info *frame)
-{
+ return *this_prologue_cache;
}
-
-/* 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)
+/* 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 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)
+ 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)
{
- *reg = SP_REGNUM;
- *offset = -(get_frame_extra_info (dummy)->stack_size);
+ CORE_ADDR fp = get_frame_register_unsigned (this_frame, E_A3_REGNUM);
+ return fp - p->frame_ptr_offset;
}
else
{
- *reg = A3_REGNUM;
- *offset = 0;
+ CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
+ return sp - p->frame_size;
}
}
-static int
-mn10300_reg_struct_has_addr (int gcc_p, struct type *type)
+/* Here is a dummy implementation. */
+static struct frame_id
+mn10300_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
- return (TYPE_LENGTH (type) > 8);
+ 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);
}
-static struct type *
-mn10300_register_virtual_type (int reg)
+static void
+mn10300_frame_this_id (struct frame_info *this_frame,
+ void **this_prologue_cache,
+ struct frame_id *this_id)
{
- return builtin_type_int;
-}
+ *this_id = frame_id_build (mn10300_frame_base (this_frame,
+ this_prologue_cache),
+ get_frame_func (this_frame));
-static int
-mn10300_register_byte (int reg)
-{
- return (reg * 4);
}
-static int
-mn10300_register_virtual_size (int reg)
+static struct value *
+mn10300_frame_prev_register (struct frame_info *this_frame,
+ void **this_prologue_cache, int regnum)
{
- return 4;
+ 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 int
-mn10300_register_raw_size (int reg)
+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)
{
- return 4;
+ ULONGEST pc;
+
+ pc = frame_unwind_register_unsigned (this_frame, E_PC_REGNUM);
+ return pc;
}
-/* If DWARF2 is a register number appearing in Dwarf2 debug info, then
- mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
- register number. Why don't Dwarf2 and GDB use the same numbering?
- Who knows? But since people have object files lying around with
- the existing Dwarf2 numbering, and other people have written stubs
- 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)
+static CORE_ADDR
+mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
- /* This table is supposed to be shaped like the REGISTER_NAMES
- 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
- };
- 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);
+ ULONGEST sp;
- return dwarf2_to_gdb[dwarf2];
+ sp = frame_unwind_register_unsigned (this_frame, E_SP_REGNUM);
+ return sp;
}
static void
-mn10300_print_register (const char *name, int regnum, int reg_width)
+mn10300_frame_unwind_init (struct gdbarch *gdbarch)
{
- char raw_buffer[MAX_REGISTER_SIZE];
+ 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);
+}
- if (reg_width)
- printf_filtered ("%*s: ", reg_width, name);
- else
- printf_filtered ("%s: ", name);
+/* Function: push_dummy_call
+ *
+ * Set up machine state for a target call, including
+ * function arguments, stack, return address, etc.
+ *
+ */
+
+static CORE_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)
+{
+ 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 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. */
+ sp &= ~3;
+
+ /* Now make space on the stack for the args.
- /* Get the data */
- if (!frame_register_read (deprecated_selected_frame, regnum, raw_buffer))
+ XXX This doesn't appear to handle pass-by-invisible reference
+ arguments. */
+ regs_used = struct_return ? 1 : 0;
+ for (len = 0, argnum = 0; argnum < nargs; argnum++)
+ {
+ arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
+ while (regs_used < 2 && arg_len > 0)
+ {
+ regs_used++;
+ arg_len -= push_size;
+ }
+ len += arg_len;
+ }
+
+ /* Allocate stack space. */
+ sp -= len;
+
+ if (struct_return)
{
- printf_filtered ("[invalid]");
- return;
+ regs_used = 1;
+ regcache_cooked_write_unsigned (regcache, E_D0_REGNUM, struct_addr);
}
else
+ regs_used = 0;
+
+ /* Push all arguments onto the stack. */
+ for (argnum = 0; argnum < nargs; argnum++)
{
- int byte;
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ /* FIXME what about structs? Unions? */
+ if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
+ && TYPE_LENGTH (value_type (*args)) > 8)
{
- for (byte = DEPRECATED_REGISTER_RAW_SIZE (regnum) - DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum);
- byte < DEPRECATED_REGISTER_RAW_SIZE (regnum);
- byte++)
- printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
+ /* Change to pointer-to-type. */
+ arg_len = push_size;
+ store_unsigned_integer (valbuf, push_size, byte_order,
+ value_address (*args));
+ val = &valbuf[0];
}
else
{
- for (byte = DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum) - 1;
- byte >= 0;
- byte--)
- printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
+ arg_len = TYPE_LENGTH (value_type (*args));
+ val = (char *) value_contents (*args);
}
- }
-}
-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
- {
- /* 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)
+ while (regs_used < 2 && arg_len > 0)
{
- 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");
+ 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 (arg_len > 0)
+ {
+ 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;
+
+ /* 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));
+ }
+
+ return sp;
}
-static CORE_ADDR
-mn10300_read_fp (void)
+/* If DWARF2 is a register number appearing in Dwarf2 debug info, then
+ mn10300_dwarf2_reg_to_regnum (DWARF2) is the corresponding GDB
+ register number. Why don't Dwarf2 and GDB use the same numbering?
+ Who knows? But since people have object files lying around with
+ the existing Dwarf2 numbering, and other people have written stubs
+ to work with the existing GDB, neither of them can change. So we
+ just have to cope. */
+static int
+mn10300_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int dwarf2)
{
- /* That's right, we're using the stack pointer as our frame pointer. */
- gdb_assert (SP_REGNUM >= 0);
- return read_register (SP_REGNUM);
-}
+ /* 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,
+ 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
+ };
-/* Dump out the mn10300 speciic architecture information. */
+ if (dwarf2 < 0
+ || dwarf2 >= ARRAY_SIZE (dwarf2_to_gdb))
+ {
+ warning (_("Bogus register number in debug info: %d"), dwarf2);
+ return -1;
+ }
-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 *
mn10300_gdbarch_init (struct gdbarch_info info,
struct gdbarch_list *arches)
{
- static LONGEST mn10300_call_dummy_words[] = { 0 };
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_max_register_raw_size (gdbarch, 4);
- set_gdbarch_deprecated_register_raw_size (gdbarch, mn10300_register_raw_size);
- set_gdbarch_deprecated_register_byte (gdbarch, mn10300_register_byte);
- set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 4);
- 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);
-
- /* Breakpoints. */
- set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
/* 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);
- set_gdbarch_deprecated_extract_return_value (gdbarch, mn10300_extract_return_value);
- set_gdbarch_deprecated_store_return_value (gdbarch, mn10300_store_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);
+ /* Breakpoints. */
+ set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
+ /* decr_pc_after_break? */
+ /* Disassembly. */
+ set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
- /* Calling functions in the inferior from GDB. */
- set_gdbarch_deprecated_call_dummy_words (gdbarch, mn10300_call_dummy_words);
- set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (mn10300_call_dummy_words));
- set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_at_entry_point);
- 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);
- set_gdbarch_deprecated_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
- set_gdbarch_use_struct_convention (gdbarch, mn10300_use_struct_convention);
+ /* Stage 2 */
+ set_gdbarch_return_value (gdbarch, mn10300_return_value);
+
+ /* 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