/* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
- Copyright 1996, 1997, 1998, 2000, 2001
- Free Software Foundation, Inc.
+
+ Copyright (C) 1996-2016 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 "arch-utils.h"
+#include "dis-asm.h"
+#include "gdbtypes.h"
+#include "regcache.h"
+#include "gdbcore.h" /* For write_memory_unsigned_integer. */
+#include "value.h"
#include "frame.h"
-#include "inferior.h"
-#include "obstack.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 "value.h"
-#include "bfd.h"
-#include "gdb_string.h"
-#include "gdbcore.h"
-#include "symfile.h"
-extern void _initialize_mn10300_tdep (void);
-static CORE_ADDR mn10300_analyze_prologue (struct frame_info *fi,
- CORE_ADDR pc);
+#include "mn10300-tdep.h"
+
-/* mn10300 private data */
-struct gdbarch_tdep
+/* The am33-2 has 64 registers. */
+#define MN10300_MAX_NUM_REGS 64
+
+/* 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 gdb_byte *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, 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)
+{
+ gdb_byte 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)
return regs[reg];
}
-static char *
-mn10300_generic_register_name (int reg)
+static const char *
+mn10300_generic_register_name (struct gdbarch *gdbarch, int reg)
{
static char *regs[] =
{ "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
}
-static char *
-am33_register_name (int reg)
+static const char *
+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);
}
-
-CORE_ADDR
-mn10300_saved_pc_after_call (struct frame_info *fi)
-{
- return read_memory_integer (read_register (SP_REGNUM), 4);
-}
-
-void
-mn10300_extract_return_value (struct type *type, char *regbuf, char *valbuf)
-{
- if (TYPE_CODE (type) == TYPE_CODE_PTR)
- memcpy (valbuf, regbuf + REGISTER_BYTE (4), TYPE_LENGTH (type));
- else
- memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (type));
-}
-CORE_ADDR
-mn10300_extract_struct_value_address (char *regbuf)
+static const char *
+am33_2_register_name (struct gdbarch *gdbarch, int reg)
{
- return extract_address (regbuf + REGISTER_BYTE (4),
- REGISTER_RAW_SIZE (4));
+ 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);
}
-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)
- write_register_bytes (REGISTER_BYTE (4), valbuf, TYPE_LENGTH (type));
- else
- write_register_bytes (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)
{
- static struct frame_info *dummy = NULL;
- if (dummy == NULL)
- {
- dummy = xmalloc (sizeof (struct frame_info));
- dummy->saved_regs = xmalloc (SIZEOF_FRAME_SAVED_REGS);
- dummy->extra_info = xmalloc (sizeof (struct frame_extra_info));
- }
- dummy->next = NULL;
- dummy->prev = NULL;
- dummy->pc = pc;
- dummy->frame = frame;
- dummy->extra_info->status = 0;
- dummy->extra_info->stack_size = 0;
- memset (dummy->saved_regs, '\000', SIZEOF_FRAME_SAVED_REGS);
- mn10300_analyze_prologue (dummy, 0);
- return dummy;
+ 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? */
-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
so we need a single byte breakpoint. Matsushita hasn't defined
one, so we defined it ourselves. */
-unsigned char *
-mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
+static const unsigned char *
+mn10300_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *bp_addr,
+ int *bp_size)
{
- static char breakpoint[] =
- {0xff};
+ static gdb_byte 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 && fi->next == NULL)
- {
- if (fi->extra_info->status & MY_FRAME_IN_SP)
- fi->frame = read_sp () - stack_size;
- else if (fi->extra_info->status & MY_FRAME_IN_FP)
- fi->frame = 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 & 0x10)
- {
- fi->saved_regs[A3_REGNUM] = fi->frame + offset;
- offset += 4;
- }
- if (movm_args & 0x20)
- {
- fi->saved_regs[A2_REGNUM] = fi->frame + offset;
- offset += 4;
- }
- if (movm_args & 0x40)
- {
- fi->saved_regs[D3_REGNUM] = fi->frame + offset;
- offset += 4;
- }
- if (movm_args & 0x80)
+/* 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++)
{
- fi->saved_regs[D2_REGNUM] = fi->frame + offset;
- offset += 4;
+ regs[rn] = pv_register (rn, 0);
+ result->reg_offset[rn] = 1;
}
- if (AM33_MODE && movm_args & 0x02)
+ 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)
{
- fi->saved_regs[E0_REGNUM + 5] = fi->frame + offset;
- fi->saved_regs[E0_REGNUM + 4] = fi->frame + offset + 4;
- fi->saved_regs[E0_REGNUM + 3] = fi->frame + offset + 8;
- fi->saved_regs[E0_REGNUM + 2] = fi->frame + offset + 12;
- }
-}
+ 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;
- For reference here's how prologues look on the mn10300:
+ save_mask = instr[1];
- With frame pointer:
- movm [d2,d3,a2,a3],sp
- mov sp,a3
- add <size>,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);
+ }
- Without frame pointer:
- movm [d2,d3,a2,a3],sp (if needed)
- add <size>,sp
+ pc += 2;
+ after_last_frame_setup_insn = pc;
+ }
+ /* mov sp, aN */
+ else if ((instr[0] & 0xfc) == 0x3c)
+ {
+ int aN = instr[0] & 0x03;
- 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. */
+ regs[E_A0_REGNUM + aN] = regs[E_SP_REGNUM];
-/* Analyze the prologue to determine where registers are saved,
- the end of the prologue, etc etc. Return the end of the prologue
- scanned.
+ 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;
- We store into FI (if non-null) several tidbits of information:
+ regs[E_A0_REGNUM + aN] = regs[E_A0_REGNUM + aM];
- * 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.
+ 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;
- * fsr -- Addresses of registers saved in the stack by this frame.
+ regs[E_D0_REGNUM + dN] = regs[E_D0_REGNUM + dM];
- * status -- A (relatively) generic status indicator. It's a bitmask
- with the following bits:
+ 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;
- 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.
+ regs[E_D0_REGNUM + dN] = regs[E_A0_REGNUM + aM];
- MY_FRAME_IN_FP: The base of the current frame is in the
- frame pointer register ($a2).
+ 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;
- 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. */
+ regs[E_A0_REGNUM + aN] = regs[E_D0_REGNUM + dM];
-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;
+ pc += 2;
+ }
+ /* add imm8, SP */
+ else if (instr[0] == 0xf8 && instr[1] == 0xfe)
+ {
+ gdb_byte buf[1];
+ LONGEST imm8;
- /* Use the PC in the frame if it's provided to look up the
- start of this function. */
- pc = (fi ? fi->pc : pc);
- /* Find the start of this function. */
- status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
- /* 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;
- }
+ imm8 = extract_signed_integer (buf, 1, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm8);
- /* If we're in start, then give up. */
- if (strcmp (name, "start") == 0)
- {
- if (fi != NULL)
- fi->extra_info->status = NO_MORE_FRAMES;
- return pc;
- }
+ 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;
- /* At the start of a function our frame is in the stack pointer. */
- if (fi)
- fi->extra_info->status = MY_FRAME_IN_SP;
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- /* 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;
+ imm16 = extract_signed_integer (buf, 2, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm16);
- /* 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.
+ 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;
- In this case fi->frame is bogus, we need to fix it. */
- if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
- {
- if (fi->next == NULL)
- fi->frame = read_sp ();
- return fi->pc;
- }
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- /* Similarly if we're stopped on the first insn of a prologue as our
- frame hasn't been allocated yet. */
- if (fi && fi->pc == func_addr)
- {
- if (fi->next == NULL)
- fi->frame = read_sp ();
- return fi->pc;
- }
- /* Figure out where to stop scanning. */
- stop = fi ? fi->pc : func_end;
+ imm32 = extract_signed_integer (buf, 4, byte_order);
+ regs[E_SP_REGNUM] = pv_add_constant (regs[E_SP_REGNUM], imm32);
- /* Don't walk off the end of the function. */
- stop = stop > func_end ? func_end : stop;
+ 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;
- /* Start scanning on the first instruction of this function. */
- addr = func_addr;
+ aN = instr[0] & 0x03;
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
- /* Suck in two bytes. */
- status = read_memory_nobpt (addr, buf, 2);
- if (status != 0)
- {
- fix_frame_pointer (fi, 0);
- return addr;
- }
+ regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
+ imm8);
- /* First see if this insn sets the stack pointer; if so, it's something
- we won't understand, so quit now. */
- if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
- {
- if (fi)
- fi->extra_info->status = NO_MORE_FRAMES;
- return addr;
- }
+ pc += 2;
+ }
+ /* add imm16, aN */
+ else if (instr[0] == 0xfa && (instr[1] & 0xfc) == 0xd0)
+ {
+ int aN;
+ LONGEST imm16;
+ gdb_byte buf[2];
- /* Now look for movm [regs],sp, which saves the callee saved registers.
+ aN = instr[1] & 0x03;
- 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;
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- addr += 2;
- /* Quit now if we're beyond the stop point. */
- if (addr >= stop)
- {
- /* Fix fi->frame since it's bogus at this point. */
- if (fi && fi->next == NULL)
- fi->frame = read_sp ();
+ imm16 = extract_signed_integer (buf, 2, byte_order);
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
+ regs[E_A0_REGNUM + aN] = pv_add_constant (regs[E_A0_REGNUM + aN],
+ imm16);
- /* Get the next two bytes so the prologue scan can continue. */
- status = read_memory_nobpt (addr, buf, 2);
- if (status != 0)
+ pc += 4;
+ }
+ /* add imm32, aN */
+ else if (instr[0] == 0xfc && (instr[1] & 0xfc) == 0xd0)
{
- /* Fix fi->frame since it's bogus at this point. */
- if (fi && fi->next == NULL)
- fi->frame = read_sp ();
+ int aN;
+ LONGEST imm32;
+ gdb_byte buf[4];
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
- }
+ aN = instr[1] & 0x03;
- /* 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, 4);
+ if (status != 0)
+ break;
- /* The frame pointer is now valid. */
- if (fi)
- {
- fi->extra_info->status |= MY_FRAME_IN_FP;
- fi->extra_info->status &= ~MY_FRAME_IN_SP;
- }
+ imm32 = extract_signed_integer (buf, 2, byte_order);
- /* Quit now if we're beyond the stop point. */
- if (addr >= stop)
+ 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)
{
- /* Fix fi->frame if it's bogus at this point. */
- fix_frame_pointer (fi, 0);
+ int fsM, sM, Y, rN;
+ 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;
- /* Get two more bytes so scanning can continue. */
- 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);
+ status = target_read_memory (pc + 2, buf, 1);
+ 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;
- /* Next we should allocate the local frame. No more prologue insns
- are found after allocating the local frame.
+ pv_area_store (stack, regs[translate_rreg (rN)], 4,
+ regs[E_FS0_REGNUM + fsM]);
- Search for add imm8,sp (0xf8feXX)
- or add imm16,sp (0xfafeXXXX)
- or add imm32,sp (0xfcfeXXXXXXXX).
+ pc += 3;
+ }
+ /* fmov fsM, (sp) */
+ else if (instr[0] == 0xf9 && (instr[1] & 0xfd) == 0x34)
+ {
+ int fsM, sM, Y;
+ gdb_byte buf[1];
- If none of the above was found, then this prologue has no
- additional stack. */
+ Y = (instr[1] & 0x02) >> 1;
- 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);
+ status = target_read_memory (pc + 2, buf, 1);
+ 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;
+ fsM = (Y << 4) | sM;
- 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;
+ pv_area_store (stack, regs[E_SP_REGNUM], 4,
+ regs[E_FS0_REGNUM + fsM]);
- 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)
+ pc += 3;
+ }
+ /* 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;
- }
- /* Note the size of the stack in the frame info structure. */
- stack_size = extract_signed_integer (buf, imm_size);
- if (fi)
- fi->extra_info->stack_size = stack_size;
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
- /* We just consumed 2 + imm_size bytes. */
- addr += 2 + imm_size;
+ rI = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ sM = (buf[1] & 0xf0) >> 4;
+ Z = (buf[1] & 0x02) >> 1;
+ fsM = (Z << 4) | sM;
- /* 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);
+ pv_area_store (stack,
+ pv_add (regs[translate_rreg (rN)],
+ regs[translate_rreg (rI)]),
+ 4, regs[E_FS0_REGNUM + fsM]);
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
- }
+ 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];
- /* 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);
+ Y = (instr[1] & 0x02) >> 1;
- /* Note if/where callee saved registers were saved. */
- set_movm_offsets (fi, movm_args);
- return addr;
-}
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
-/* Function: frame_chain
- Figure out and return the caller's frame pointer given current
- frame_info struct.
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d8 = extract_signed_integer (&buf[1], 1, byte_order);
- 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? */
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d8),
+ 4, regs[E_FS0_REGNUM + fsM]);
-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 (fi->extra_info->status == 0)
- mn10300_analyze_prologue (fi, (CORE_ADDR) 0);
+ 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];
- /* Quit now if mn10300_analyze_prologue set NO_MORE_FRAMES. */
- if (fi->extra_info->status & NO_MORE_FRAMES)
- return 0;
+ Y = (instr[1] & 0x02) >> 1;
- /* Now that we've analyzed our prologue, determine the frame
- pointer for our caller.
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- If our caller has a frame pointer, then we need to
- find the entry value of $a3 to our function.
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d24 = extract_signed_integer (&buf[1], 3, byte_order);
- If fsr.regs[A3_REGNUM] is nonzero, then it's at the memory
- location pointed to by fsr.regs[A3_REGNUM].
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d24),
+ 4, regs[E_FS0_REGNUM + fsM]);
- Else it's still in $a3.
+ 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];
- If our caller does not have a frame pointer, then his
- frame base is fi->frame + -caller's stack size. */
+ Y = (instr[1] & 0x02) >> 1;
- /* 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 (FRAME_SAVED_PC (fi), fi->frame);
+ status = target_read_memory (pc + 2, buf, 5);
+ if (status != 0)
+ break;
- if (dummy->extra_info->status & MY_FRAME_IN_FP)
- {
- /* Our caller has a frame pointer. So find the frame in $a3 or
- in the stack. */
- if (fi->saved_regs[A3_REGNUM])
- return (read_memory_integer (fi->saved_regs[A3_REGNUM], REGISTER_SIZE));
- else
- return read_register (A3_REGNUM);
- }
- else
- {
- int adjust = 0;
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ d32 = extract_signed_integer (&buf[1], 4, byte_order);
- adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
- adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
- adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
- adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
- if (AM33_MODE)
- {
- adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
- adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
- adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
- adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
+ pv_area_store (stack,
+ pv_add_constant (regs[translate_rreg (rN)], d32),
+ 4, regs[E_FS0_REGNUM + fsM]);
+
+ 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];
- /* Our caller does not have a frame pointer. So his frame starts
- at the base of our frame (fi->frame) + register save space
- + <his size>. */
- return fi->frame + adjust + -dummy->extra_info->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, 2);
+ if (status != 0)
+ break;
-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;
+ 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: pop_frame
- This routine gets called when either the user uses the `return'
- command, or the call dummy breakpoint gets hit. */
+ 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];
-void
-mn10300_pop_frame (struct frame_info *frame)
-{
- int regnum;
+ Y = (instr[1] & 0x02) >> 1;
- if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
- generic_pop_dummy_frame ();
- else
- {
- write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
- /* Restore any saved registers. */
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (frame->saved_regs[regnum] != 0)
- {
- ULONGEST value;
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d24 = extract_signed_integer (&buf[1], 3, byte_order);
- value = read_memory_unsigned_integer (frame->saved_regs[regnum],
- REGISTER_RAW_SIZE (regnum));
- write_register (regnum, value);
- }
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d24),
+ 4, regs[E_FS0_REGNUM + fsM]);
- /* Actually cut back the stack. */
- write_register (SP_REGNUM, FRAME_FP (frame));
+ 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];
- /* Don't we need to set the PC?!? XXX FIXME. */
- }
+ Y = (instr[1] & 0x02) >> 1;
- /* Throw away any cached frame information. */
- flush_cached_frames ();
-}
+ status = target_read_memory (pc + 2, buf, 5);
+ if (status != 0)
+ break;
-/* Function: push_arguments
- Setup arguments for a call to the target. Arguments go in
- order on the stack. */
+ sM = (buf[0] & 0xf0) >> 4;
+ fsM = (Y << 4) | sM;
+ d32 = extract_signed_integer (&buf[1], 4, byte_order);
-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;
+ pv_area_store (stack,
+ pv_add_constant (regs[E_SP_REGNUM], d32),
+ 4, regs[E_FS0_REGNUM + fsM]);
- /* 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;
+ 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 make space on the stack for the args.
+ Y = (instr[1] & 0x02) >> 1;
- 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;
+ status = target_read_memory (pc + 2, buf, 1);
+ if (status != 0)
+ break;
- while (regsused < 2 && arg_length > 0)
- {
- regsused++;
- arg_length -= 4;
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+
+ 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], 4);
+
+ pc += 3;
}
- len += arg_length;
- }
+ /* 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];
- /* Allocate stack space. */
- sp -= len;
+ Y = (instr[1] & 0x02) >> 1;
- regsused = struct_return ? 1 : 0;
- /* Push all arguments onto the stack. */
- for (argnum = 0; argnum < nargs; argnum++)
- {
- int len;
- char *val;
+ status = target_read_memory (pc + 2, buf, 2);
+ if (status != 0)
+ break;
+
+ sM = (buf[0] & 0xf0) >> 4;
+ rN = buf[0] & 0x0f;
+ fsM = (Y << 4) | sM;
+ imm8 = extract_signed_integer (&buf[1], 1, byte_order);
- /* XXX Check this. What about UNIONS? */
- if (TYPE_CODE (VALUE_TYPE (*args)) == TYPE_CODE_STRUCT
- && TYPE_LENGTH (VALUE_TYPE (*args)) > 8)
+ 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);
+
+ pc += 4;
+ }
+ /* fmov fsM, (rN+, imm24) */
+ else if (instr[0] == 0xfd && (instr[1] & 0xfd) == 0x31)
{
- /* XXX Wrong, we want a pointer to this argument. */
- len = TYPE_LENGTH (VALUE_TYPE (*args));
- val = (char *) VALUE_CONTENTS (*args);
+ int fsM, sM, Y, rN, rN_regnum;
+ LONGEST imm24;
+ gdb_byte buf[4];
+
+ 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;
}
- else
+ /* fmov fsM, (rN+, imm32) */
+ else if (instr[0] == 0xfe && (instr[1] & 0xfd) == 0x31)
{
- len = TYPE_LENGTH (VALUE_TYPE (*args));
- val = (char *) VALUE_CONTENTS (*args);
+ 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;
}
+ /* mov imm8, aN */
+ else if ((instr[0] & 0xf0) == 0x90)
+ {
+ int aN = 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_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;
+
+ 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;
+ }
+ /* 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;
+
+ imm8 = extract_signed_integer (&instr[1], 1, byte_order);
- while (len > 0)
+ 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;
+
+ 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;
+
+ status = target_read_memory (pc + 2, buf, 4);
+ if (status != 0)
+ break;
+
+ imm32 = extract_signed_integer (buf, 4, byte_order);
+ regs[E_D0_REGNUM + dN] = pv_constant (imm32);
+ pc += 6;
+ }
+ else
{
- write_memory (sp + stack_offset, val, 4);
- len -= 4;
- val += 4;
- stack_offset += 4;
+ /* We've hit some instruction that we don't recognize. Hopefully,
+ we have enough to do prologue analysis. */
+ break;
}
-
- 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 */
+ /* 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;
-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, CALL_DUMMY_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;
-CORE_ADDR
-mn10300_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
-{
- /* The structure return address is passed as the first argument. */
- write_register (0, addr);
- return sp;
+ 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. */
-CORE_ADDR
-mn10300_frame_saved_pc (struct frame_info *fi)
+static CORE_ADDR
+mn10300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
{
- int adjust = 0;
+ const char *name;
+ CORE_ADDR func_addr, func_end;
+ struct mn10300_prologue p;
- adjust += (fi->saved_regs[D2_REGNUM] ? 4 : 0);
- adjust += (fi->saved_regs[D3_REGNUM] ? 4 : 0);
- adjust += (fi->saved_regs[A2_REGNUM] ? 4 : 0);
- adjust += (fi->saved_regs[A3_REGNUM] ? 4 : 0);
- if (AM33_MODE)
- {
- adjust += (fi->saved_regs[E0_REGNUM + 5] ? 4 : 0);
- adjust += (fi->saved_regs[E0_REGNUM + 4] ? 4 : 0);
- adjust += (fi->saved_regs[E0_REGNUM + 3] ? 4 : 0);
- adjust += (fi->saved_regs[E0_REGNUM + 2] ? 4 : 0);
- }
+ /* Try to find the extent of the function that contains PC. */
+ if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
+ return pc;
- return (read_memory_integer (fi->frame + adjust, REGISTER_SIZE));
+ mn10300_analyze_prologue (gdbarch, pc, func_end, &p);
+ return p.prologue_end;
}
-/* 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 fi->pc 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.
+/* 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;
- 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 run_stack_dummy). */
+ *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct mn10300_prologue);
-void
-mn10300_init_extra_frame_info (struct frame_info *fi)
-{
- if (fi->next)
- fi->pc = FRAME_SAVED_PC (fi->next);
+ func_start = get_frame_func (this_frame);
+ stop_addr = get_frame_pc (this_frame);
- frame_saved_regs_zalloc (fi);
- fi->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
+ /* 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;
- fi->extra_info->status = 0;
- fi->extra_info->stack_size = 0;
+ mn10300_analyze_prologue (get_frame_arch (this_frame),
+ func_start, stop_addr,
+ ((struct mn10300_prologue *)
+ *this_prologue_cache));
+ }
- mn10300_analyze_prologue (fi, 0);
+ return (struct mn10300_prologue *) *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. */
-
-void
-mn10300_virtual_frame_pointer (CORE_ADDR pc, long *reg, long *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 (dummy->extra_info->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 = -(dummy->extra_info->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)
+static struct value *
+mn10300_frame_prev_register (struct frame_info *this_frame,
+ void **this_prologue_cache, int regnum)
{
- return (reg * 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_virtual_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;
}
-static int
-mn10300_register_raw_size (int reg)
+static CORE_ADDR
+mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
{
- return 4;
+ ULONGEST sp;
+
+ 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 = alloca (MAX_REGISTER_RAW_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;
+ const gdb_byte *val;
+ gdb_byte 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.
+
+ 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;
- /* Get the data */
- if (read_relative_register_raw_bytes (regnum, raw_buffer))
+ 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 == BIG_ENDIAN)
+ /* FIXME what about structs? Unions? */
+ if (TYPE_CODE (value_type (*args)) == TYPE_CODE_STRUCT
+ && TYPE_LENGTH (value_type (*args)) > 8)
{
- for (byte = REGISTER_RAW_SIZE (regnum) - REGISTER_VIRTUAL_SIZE (regnum);
- byte < 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 = REGISTER_VIRTUAL_SIZE (regnum) - 1;
- byte >= 0;
- byte--)
- printf_filtered ("%02x", (unsigned char) raw_buffer[byte]);
+ arg_len = TYPE_LENGTH (value_type (*args));
+ val = 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)
- {
- 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");
+ while (regs_used < 2 && arg_len > 0)
+ {
+ 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++;
}
-}
-/* Dump out the mn10300 speciic architecture information. */
+ /* Make space for the flushback area. */
+ sp -= 8;
-static void
-mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+ /* 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;
+}
+
+/* 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)
{
- struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
- fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
- tdep->am33_mode);
+ /* 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[] = {
+ E_D0_REGNUM, E_D1_REGNUM, E_D2_REGNUM, E_D3_REGNUM,
+ E_A0_REGNUM, E_A1_REGNUM, E_A2_REGNUM, E_A3_REGNUM,
+ -1, E_SP_REGNUM,
+
+ E_E0_REGNUM, E_E1_REGNUM, E_E2_REGNUM, E_E3_REGNUM,
+ E_E4_REGNUM, E_E5_REGNUM, E_E6_REGNUM, E_E7_REGNUM,
+
+ E_FS0_REGNUM + 0, E_FS0_REGNUM + 1, E_FS0_REGNUM + 2, E_FS0_REGNUM + 3,
+ E_FS0_REGNUM + 4, E_FS0_REGNUM + 5, E_FS0_REGNUM + 6, E_FS0_REGNUM + 7,
+
+ E_FS0_REGNUM + 8, E_FS0_REGNUM + 9, E_FS0_REGNUM + 10, E_FS0_REGNUM + 11,
+ E_FS0_REGNUM + 12, E_FS0_REGNUM + 13, E_FS0_REGNUM + 14, E_FS0_REGNUM + 15,
+
+ E_FS0_REGNUM + 16, E_FS0_REGNUM + 17, E_FS0_REGNUM + 18, E_FS0_REGNUM + 19,
+ E_FS0_REGNUM + 20, E_FS0_REGNUM + 21, E_FS0_REGNUM + 22, E_FS0_REGNUM + 23,
+
+ E_FS0_REGNUM + 24, E_FS0_REGNUM + 25, E_FS0_REGNUM + 26, E_FS0_REGNUM + 27,
+ E_FS0_REGNUM + 28, E_FS0_REGNUM + 29, E_FS0_REGNUM + 30, E_FS0_REGNUM + 31,
+
+ E_MDR_REGNUM, E_PSW_REGNUM, E_PC_REGNUM
+ };
+
+ if (dwarf2 < 0
+ || dwarf2 >= ARRAY_SIZE (dwarf2_to_gdb))
+ return -1;
+
+ 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));
+
+ tdep = XNEW (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;
}
- set_gdbarch_register_size (gdbarch, 4);
- set_gdbarch_max_register_raw_size (gdbarch, 4);
- set_gdbarch_register_virtual_type (gdbarch, mn10300_register_virtual_type);
- set_gdbarch_register_byte (gdbarch, mn10300_register_byte);
- set_gdbarch_register_virtual_size (gdbarch, mn10300_register_virtual_size);
- set_gdbarch_register_raw_size (gdbarch, mn10300_register_raw_size);
- set_gdbarch_call_dummy_p (gdbarch, 1);
- set_gdbarch_register_name (gdbarch, register_name);
- set_gdbarch_use_generic_dummy_frames (gdbarch, 1);
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 0);
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_get_saved_register (gdbarch, generic_get_saved_register);
- set_gdbarch_push_arguments (gdbarch, mn10300_push_arguments);
- set_gdbarch_push_return_address (gdbarch, mn10300_push_return_address);
- set_gdbarch_frame_chain_valid (gdbarch, generic_file_frame_chain_valid);
- set_gdbarch_reg_struct_has_addr (gdbarch, mn10300_reg_struct_has_addr);
- set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
+ /* By default, chars are unsigned. */
+ set_gdbarch_char_signed (gdbarch, 0);
+
+ /* Registers. */
set_gdbarch_num_regs (gdbarch, num_regs);
- set_gdbarch_do_registers_info (gdbarch, mn10300_do_registers_info);
+ 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);
+
+ /* 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);
+
+ /* 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;
+ mn10300_frame_unwind_init (gdbarch);
+
+ /* Hook in ABI-specific overrides, if they have been registered. */
+ gdbarch_init_osabi (info, gdbarch);
return gdbarch;
}
-void
-_initialize_mn10300_tdep (void)
+/* Dump out the mn10300 specific architecture information. */
+
+static void
+mn10300_dump_tdep (struct gdbarch *gdbarch, struct ui_file *file)
{
-/* printf("_initialize_mn10300_tdep\n"); */
+ struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
+ fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
+ tdep->am33_mode);
+}
- tm_print_insn = print_insn_mn10300;
+/* Provide a prototype to silence -Wmissing-prototypes. */
+extern initialize_file_ftype _initialize_mn10300_tdep;
- register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);
+void
+_initialize_mn10300_tdep (void)
+{
+ gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
}
+
projects / deliverable / binutils-gdb.git / blobdiff