/* Target dependent code for the Motorola 68000 series.
- Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001
+ Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2000, 2001,
+ 2002, 2003
Free Software Foundation, Inc.
This file is part of GDB.
#include "inferior.h"
#include "regcache.h"
#include "arch-utils.h"
+#include "osabi.h"
+
+#include "m68k-tdep.h"
\f
#define P_LINKL_FP 0x480e
#define P_FMOVM 0xf237
#define P_TRAP 0x4e40
-enum
+
+#define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
+#define REGISTER_BYTES_NOFP (16*4 + 8)
+
+#define NUM_FREGS (NUM_REGS-24)
+
+/* Offset from SP to first arg on stack at first instruction of a function */
+
+#define SP_ARG0 (1 * 4)
+
+/* This was determined by experimentation on hp300 BSD 4.3. Perhaps
+ it corresponds to some offset in /usr/include/sys/user.h or
+ something like that. Using some system include file would
+ have the advantage of probably being more robust in the face
+ of OS upgrades, but the disadvantage of being wrong for
+ cross-debugging. */
+
+#define SIG_PC_FP_OFFSET 530
+
+#define TARGET_M68K
+
+
+#if !defined (BPT_VECTOR)
+#define BPT_VECTOR 0xf
+#endif
+
+#if !defined (REMOTE_BPT_VECTOR)
+#define REMOTE_BPT_VECTOR 1
+#endif
+
+
+static void m68k_frame_init_saved_regs (struct frame_info *frame_info);
+
+
+/* gdbarch_breakpoint_from_pc is set to m68k_local_breakpoint_from_pc
+ so m68k_remote_breakpoint_from_pc is currently not used. */
+
+static const unsigned char *
+m68k_remote_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
+{
+ static unsigned char break_insn[] = {0x4e, (0x40 | REMOTE_BPT_VECTOR)};
+ *lenptr = sizeof (break_insn);
+ return break_insn;
+}
+
+static const unsigned char *
+m68k_local_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
{
- E_FP_REGNUM = 14, /* Contains address of executing stack frame */
- E_SP_REGNUM = 15, /* Contains address of top of stack */
- E_PS_REGNUM = 16, /* Contains processor status */
- E_PC_REGNUM = 17, /* Contains program counter */
- E_FP0_REGNUM = 18 /* Floating point register 0 */
-};
+ static unsigned char break_insn[] = {0x4e, (0x40 | BPT_VECTOR)};
+ *lenptr = sizeof (break_insn);
+ return break_insn;
+}
-void m68k_frame_init_saved_regs (struct frame_info *frame_info);
static int
-m68k_register_bytes_ok (numbytes)
+m68k_register_bytes_ok (long numbytes)
{
return ((numbytes == REGISTER_BYTES_FP)
|| (numbytes == REGISTER_BYTES_NOFP));
/* Number of bytes of storage in the actual machine representation
for register regnum. On the 68000, all regs are 4 bytes
except the floating point regs which are 12 bytes. */
-/* Note that the unsigned cast here forces the result of the
- subtraction to very high positive values if regnum < FP0_REGNUM */
static int
m68k_register_raw_size (int regnum)
{
- return (((unsigned) (regnum) - FP0_REGNUM) < 8 ? 12 : 4);
+ return (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 8 ? 12 : 4);
}
/* Number of bytes of storage in the program's representation
static int
m68k_register_virtual_size (int regnum)
{
- return (((unsigned) (regnum) - FP0_REGNUM) < 8 ? 12 : 4);
+ return (regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 8 ? 12 : 4);
}
-/* Return the GDB type object for the "standard" data type of data
- in register N. This should be int for D0-D7, long double for FP0-FP7,
- and void pointer for all others (A0-A7, PC, SR, FPCONTROL etc).
- Note, for registers which contain addresses return pointer to void,
- not pointer to char, because we don't want to attempt to print
- the string after printing the address. */
+/* Return the GDB type object for the "standard" data type of data in
+ register N. This should be int for D0-D7, SR, FPCONTROL and
+ FPSTATUS, long double for FP0-FP7, and void pointer for all others
+ (A0-A7, PC, FPIADDR). Note, for registers which contain
+ addresses return pointer to void, not pointer to char, because we
+ don't want to attempt to print the string after printing the
+ address. */
static struct type *
m68k_register_virtual_type (int regnum)
{
- if ((unsigned) regnum >= FPC_REGNUM)
- return lookup_pointer_type (builtin_type_void);
- else if ((unsigned) regnum >= FP0_REGNUM)
- return builtin_type_long_double;
- else if ((unsigned) regnum >= A0_REGNUM)
- return lookup_pointer_type (builtin_type_void);
- else
- return builtin_type_int;
+ if (regnum >= FP0_REGNUM && regnum <= FP0_REGNUM + 7)
+ return builtin_type_m68881_ext;
+
+ if (regnum == M68K_FPI_REGNUM || regnum == PC_REGNUM)
+ return builtin_type_void_func_ptr;
+
+ if (regnum == M68K_FPC_REGNUM || regnum == M68K_FPS_REGNUM
+ || regnum == PS_REGNUM)
+ return builtin_type_int32;
+
+ if (regnum >= M68K_A0_REGNUM && regnum <= M68K_A0_REGNUM + 7)
+ return builtin_type_void_data_ptr;
+
+ return builtin_type_int32;
}
/* Function: m68k_register_name
static int
m68k_register_byte (int regnum)
{
- if (regnum >= FPC_REGNUM)
- return (((regnum - FPC_REGNUM) * 4) + 168);
+ if (regnum >= M68K_FPC_REGNUM)
+ return (((regnum - M68K_FPC_REGNUM) * 4) + 168);
else if (regnum >= FP0_REGNUM)
return (((regnum - FP0_REGNUM) * 12) + 72);
else
static void
m68k_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
{
- write_register (A1_REGNUM, addr);
+ write_register (M68K_A1_REGNUM, addr);
}
/* Extract from an array regbuf containing the (raw) register state
static void
m68k_store_return_value (struct type *type, char *valbuf)
{
- write_register_bytes (0, valbuf, TYPE_LENGTH (type));
+ deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (type));
}
/* Describe the pointer in each stack frame to the previous stack frame
(its caller). */
-/* FRAME_CHAIN takes a frame's nominal address and produces the frame's
- chain-pointer.
- In the case of the 68000, the frame's nominal address
- is the address of a 4-byte word containing the calling frame's address. */
+/* DEPRECATED_FRAME_CHAIN takes a frame's nominal address and produces
+ the frame's chain-pointer. In the case of the 68000, the frame's
+ nominal address is the address of a 4-byte word containing the
+ calling frame's address. */
/* If we are chaining from sigtramp, then manufacture a sigtramp frame
(which isn't really on the stack. I'm not sure this is right for anything
static CORE_ADDR
m68k_frame_chain (struct frame_info *thisframe)
{
- if (thisframe->signal_handler_caller)
- return thisframe->frame;
- else if (!inside_entry_file ((thisframe)->pc))
- return read_memory_integer ((thisframe)->frame, 4);
+ if (get_frame_type (thisframe) == SIGTRAMP_FRAME)
+ return get_frame_base (thisframe);
+ else if (!inside_entry_file (get_frame_pc (thisframe)))
+ return read_memory_unsigned_integer (get_frame_base (thisframe), 4);
else
return 0;
}
static int
m68k_frameless_function_invocation (struct frame_info *fi)
{
- if (fi->signal_handler_caller)
+ if (get_frame_type (fi) == SIGTRAMP_FRAME)
return 0;
else
return frameless_look_for_prologue (fi);
static CORE_ADDR
m68k_frame_saved_pc (struct frame_info *frame)
{
- if (frame->signal_handler_caller)
+ if (get_frame_type (frame) == SIGTRAMP_FRAME)
{
- if (frame->next)
- return read_memory_integer (frame->next->frame + SIG_PC_FP_OFFSET, 4);
+ if (get_next_frame (frame))
+ return read_memory_unsigned_integer (get_frame_base (get_next_frame (frame))
+ + SIG_PC_FP_OFFSET, 4);
else
- return read_memory_integer (read_register (SP_REGNUM)
- + SIG_PC_FP_OFFSET - 8, 4);
+ return read_memory_unsigned_integer (read_register (SP_REGNUM)
+ + SIG_PC_FP_OFFSET - 8, 4);
}
else
- return read_memory_integer (frame->frame + 4, 4);
+ return read_memory_unsigned_integer (get_frame_base (frame) + 4, 4);
}
-/* The only reason this is here is the tm-altos.h reference below. It
- was moved back here from tm-m68k.h. FIXME? */
-
-extern CORE_ADDR
-altos_skip_prologue (CORE_ADDR pc)
-{
- register int op = read_memory_integer (pc, 2);
- if (op == P_LINKW_FP)
- pc += 4; /* Skip link #word */
- else if (op == P_LINKL_FP)
- pc += 6; /* Skip link #long */
- /* Not sure why branches are here. */
- /* From tm-altos.h */
- else if (op == 0060000)
- pc += 4; /* Skip bra #word */
- else if (op == 00600377)
- pc += 6; /* skip bra #long */
- else if ((op & 0177400) == 0060000)
- pc += 2; /* skip bra #char */
- return pc;
-}
-
int
delta68_in_sigtramp (CORE_ADDR pc, char *name)
{
{
/* we assume here that the only frameless functions are the system calls
or other functions who do not put anything on the stack. */
- if (frame_info->signal_handler_caller)
- return frame_info->frame + 12;
+ if (get_frame_type (frame_info) == SIGTRAMP_FRAME)
+ return get_frame_base (frame_info) + 12;
else if (frameless_look_for_prologue (frame_info))
{
/* Check for an interrupted system call */
- if (frame_info->next && frame_info->next->signal_handler_caller)
- return frame_info->next->frame + 16;
+ if (get_next_frame (frame_info) && (get_frame_type (get_next_frame (frame_info)) == SIGTRAMP_FRAME))
+ return get_frame_base (get_next_frame (frame_info)) + 16;
else
- return frame_info->frame + 4;
+ return get_frame_base (frame_info) + 4;
}
else
- return frame_info->frame;
+ return get_frame_base (frame_info);
}
CORE_ADDR
delta68_frame_saved_pc (struct frame_info *frame_info)
{
- return read_memory_integer (delta68_frame_args_address (frame_info) + 4, 4);
-}
-
-/* Return number of args passed to a frame.
- Can return -1, meaning no way to tell. */
-
-int
-isi_frame_num_args (struct frame_info *fi)
-{
- int val;
- CORE_ADDR pc = FRAME_SAVED_PC (fi);
- int insn = 0177777 & read_memory_integer (pc, 2);
- val = 0;
- if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */
- val = read_memory_integer (pc + 2, 2);
- else if ((insn & 0170777) == 0050217 /* addql #N, sp */
- || (insn & 0170777) == 0050117) /* addqw */
- {
- val = (insn >> 9) & 7;
- if (val == 0)
- val = 8;
- }
- else if (insn == 0157774) /* addal #WW, sp */
- val = read_memory_integer (pc + 2, 4);
- val >>= 2;
- return val;
+ return read_memory_unsigned_integer (delta68_frame_args_address (frame_info)
+ + 4, 4);
}
int
delta68_frame_num_args (struct frame_info *fi)
{
int val;
- CORE_ADDR pc = FRAME_SAVED_PC (fi);
- int insn = 0177777 & read_memory_integer (pc, 2);
- val = 0;
- if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */
- val = read_memory_integer (pc + 2, 2);
- else if ((insn & 0170777) == 0050217 /* addql #N, sp */
- || (insn & 0170777) == 0050117) /* addqw */
- {
- val = (insn >> 9) & 7;
- if (val == 0)
- val = 8;
- }
- else if (insn == 0157774) /* addal #WW, sp */
- val = read_memory_integer (pc + 2, 4);
- val >>= 2;
- return val;
-}
-
-int
-news_frame_num_args (struct frame_info *fi)
-{
- int val;
- CORE_ADDR pc = FRAME_SAVED_PC (fi);
- int insn = 0177777 & read_memory_integer (pc, 2);
+ CORE_ADDR pc = DEPRECATED_FRAME_SAVED_PC (fi);
+ int insn = read_memory_unsigned_integer (pc, 2);
val = 0;
if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */
val = read_memory_integer (pc + 2, 2);
into a call sequence of the above form stored at DUMMYNAME.
We use the BFD routines to store a big-endian value of known size. */
-void
+static void
m68k_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
struct value **args, struct type *type, int gcc_p)
{
- bfd_putb32 (fun, (unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 2);
+ bfd_putb32 (fun, (unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 2);
bfd_putb32 (nargs * 4,
- (unsigned char *) dummy + CALL_DUMMY_START_OFFSET + 8);
+ (unsigned char *) dummy + DEPRECATED_CALL_DUMMY_START_OFFSET + 8);
}
/* Push an empty stack frame, to record the current PC, etc. */
-void
+static void
m68k_push_dummy_frame (void)
{
register CORE_ADDR sp = read_register (SP_REGNUM);
char raw_buffer[12];
sp = push_word (sp, read_register (PC_REGNUM));
- sp = push_word (sp, read_register (FP_REGNUM));
- write_register (FP_REGNUM, sp);
+ sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM));
+ write_register (DEPRECATED_FP_REGNUM, sp);
/* Always save the floating-point registers, whether they exist on
this target or not. */
for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
{
- read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
+ deprecated_read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
sp = push_bytes (sp, raw_buffer, 12);
}
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
+ for (regnum = DEPRECATED_FP_REGNUM - 1; regnum >= 0; regnum--)
{
sp = push_word (sp, read_register (regnum));
}
/* Discard from the stack the innermost frame,
restoring all saved registers. */
-void
+static void
m68k_pop_frame (void)
{
register struct frame_info *frame = get_current_frame ();
register int regnum;
char raw_buffer[12];
- fp = FRAME_FP (frame);
+ fp = get_frame_base (frame);
m68k_frame_init_saved_regs (frame);
for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
{
- if (frame->saved_regs[regnum])
+ if (get_frame_saved_regs (frame)[regnum])
{
- read_memory (frame->saved_regs[regnum], raw_buffer, 12);
- write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
+ read_memory (get_frame_saved_regs (frame)[regnum], raw_buffer, 12);
+ deprecated_write_register_bytes (REGISTER_BYTE (regnum), raw_buffer,
+ 12);
}
}
- for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
+ for (regnum = DEPRECATED_FP_REGNUM - 1; regnum >= 0; regnum--)
{
- if (frame->saved_regs[regnum])
+ if (get_frame_saved_regs (frame)[regnum])
{
write_register (regnum,
- read_memory_integer (frame->saved_regs[regnum], 4));
+ read_memory_integer (get_frame_saved_regs (frame)[regnum], 4));
}
}
- if (frame->saved_regs[PS_REGNUM])
+ if (get_frame_saved_regs (frame)[PS_REGNUM])
{
write_register (PS_REGNUM,
- read_memory_integer (frame->saved_regs[PS_REGNUM], 4));
+ read_memory_integer (get_frame_saved_regs (frame)[PS_REGNUM], 4));
}
- write_register (FP_REGNUM, read_memory_integer (fp, 4));
+ write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp, 4));
write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
write_register (SP_REGNUM, fp + 8);
flush_cached_frames ();
*/
-CORE_ADDR
+static CORE_ADDR
m68k_skip_prologue (CORE_ADDR ip)
{
register CORE_ADDR limit;
while (ip < limit)
{
- op = read_memory_integer (ip, 2);
- op &= 0xFFFF;
+ op = read_memory_unsigned_integer (ip, 2);
if (op == P_LINKW_FP)
ip += 4; /* Skip link.w */
ways in the stack frame. sp is even more special:
the address we return for it IS the sp for the next frame. */
-void
+static void
m68k_frame_init_saved_regs (struct frame_info *frame_info)
{
register int regnum;
/* First possible address for a pc in a call dummy for this frame. */
CORE_ADDR possible_call_dummy_start =
- (frame_info)->frame - 28 - FP_REGNUM * 4 - 4 - 8 * 12;
+ get_frame_base (frame_info) - 28 - DEPRECATED_FP_REGNUM * 4 - 4 - 8 * 12;
int nextinsn;
- if (frame_info->saved_regs)
+ if (get_frame_saved_regs (frame_info))
return;
frame_saved_regs_zalloc (frame_info);
- memset (frame_info->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
+ memset (get_frame_saved_regs (frame_info), 0, SIZEOF_FRAME_SAVED_REGS);
- if ((frame_info)->pc >= possible_call_dummy_start
- && (frame_info)->pc <= (frame_info)->frame)
+ if (get_frame_pc (frame_info) >= possible_call_dummy_start
+ && get_frame_pc (frame_info) <= get_frame_base (frame_info))
{
/* It is a call dummy. We could just stop now, since we know
to parse the "prologue" which is part of the call dummy.
This is needlessly complex and confusing. FIXME. */
- next_addr = (frame_info)->frame;
+ next_addr = get_frame_base (frame_info);
pc = possible_call_dummy_start;
}
else
{
- pc = get_pc_function_start ((frame_info)->pc);
+ pc = get_frame_func (frame_info);
- nextinsn = read_memory_integer (pc, 2);
+ nextinsn = read_memory_unsigned_integer (pc, 2);
if (P_PEA_FP == nextinsn
- && P_MOVL_SP_FP == read_memory_integer (pc + 2, 2))
+ && P_MOVL_SP_FP == read_memory_unsigned_integer (pc + 2, 2))
{
/* pea %fp
move.l %sp, %fp */
- next_addr = frame_info->frame;
+ next_addr = get_frame_base (frame_info);
pc += 4;
}
else if (P_LINKL_FP == nextinsn)
/* Find the address above the saved
regs using the amount of storage from the link instruction. */
{
- next_addr = (frame_info)->frame + read_memory_integer (pc + 2, 4);
+ next_addr = get_frame_base (frame_info) + read_memory_integer (pc + 2, 4);
pc += 6;
}
else if (P_LINKW_FP == nextinsn)
/* Find the address above the saved
regs using the amount of storage from the link instruction. */
{
- next_addr = (frame_info)->frame + read_memory_integer (pc + 2, 2);
+ next_addr = get_frame_base (frame_info) + read_memory_integer (pc + 2, 2);
pc += 4;
}
else
goto lose;
/* If have an addal #-n, sp next, adjust next_addr. */
- if ((0177777 & read_memory_integer (pc, 2)) == 0157774)
+ if (read_memory_unsigned_integer (pc, 2) == 0157774)
next_addr += read_memory_integer (pc += 2, 4), pc += 4;
}
for (;;)
{
- nextinsn = 0xffff & read_memory_integer (pc, 2);
- regmask = read_memory_integer (pc + 2, 2);
+ nextinsn = read_memory_unsigned_integer (pc, 2);
+ regmask = read_memory_unsigned_integer (pc + 2, 2);
/* fmovemx to -(sp) */
if (0xf227 == nextinsn && (regmask & 0xff00) == 0xe000)
{
/* Regmask's low bit is for register fp7, the first pushed */
for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
if (regmask & 1)
- frame_info->saved_regs[regnum] = (next_addr -= 12);
+ get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 12);
pc += 4;
}
/* fmovemx to (fp + displacement) */
{
register CORE_ADDR addr;
- addr = (frame_info)->frame + read_memory_integer (pc + 4, 2);
+ addr = get_frame_base (frame_info) + read_memory_integer (pc + 4, 2);
/* Regmask's low bit is for register fp7, the first pushed */
for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
if (regmask & 1)
{
- frame_info->saved_regs[regnum] = addr;
+ get_frame_saved_regs (frame_info)[regnum] = addr;
addr += 12;
}
pc += 6;
for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)
if (regmask & 1)
{
- frame_info->saved_regs[regnum] = next_addr;
+ get_frame_saved_regs (frame_info)[regnum] = next_addr;
next_addr += 4;
}
pc += 4;
{
register CORE_ADDR addr;
- addr = (frame_info)->frame + read_memory_integer (pc + 4, 2);
+ addr = get_frame_base (frame_info) + read_memory_integer (pc + 4, 2);
/* Regmask's low bit is for register 0, the first written */
for (regnum = 0; regnum < 16; regnum++, regmask >>= 1)
if (regmask & 1)
{
- frame_info->saved_regs[regnum] = addr;
+ get_frame_saved_regs (frame_info)[regnum] = addr;
addr += 4;
}
pc += 6;
/* Regmask's low bit is for register 15, the first pushed */
for (regnum = 16; --regnum >= 0; regmask >>= 1)
if (regmask & 1)
- frame_info->saved_regs[regnum] = (next_addr -= 4);
+ get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4);
pc += 4;
}
/* movl r,-(sp) */
else if (0x2f00 == (0xfff0 & nextinsn))
{
regnum = 0xf & nextinsn;
- frame_info->saved_regs[regnum] = (next_addr -= 4);
+ get_frame_saved_regs (frame_info)[regnum] = (next_addr -= 4);
pc += 2;
}
/* fmovemx to index of sp */
for (regnum = FP0_REGNUM + 8; --regnum >= FP0_REGNUM; regmask >>= 1)
if (regmask & 1)
{
- frame_info->saved_regs[regnum] = next_addr;
+ get_frame_saved_regs (frame_info)[regnum] = next_addr;
next_addr += 12;
}
pc += 10;
/* clrw -(sp); movw ccr,-(sp) */
else if (0x4267 == nextinsn && 0x42e7 == regmask)
{
- frame_info->saved_regs[PS_REGNUM] = (next_addr -= 4);
+ get_frame_saved_regs (frame_info)[PS_REGNUM] = (next_addr -= 4);
pc += 4;
}
else
break;
}
lose:;
- frame_info->saved_regs[SP_REGNUM] = (frame_info)->frame + 8;
- frame_info->saved_regs[FP_REGNUM] = (frame_info)->frame;
- frame_info->saved_regs[PC_REGNUM] = (frame_info)->frame + 4;
+ get_frame_saved_regs (frame_info)[SP_REGNUM] = get_frame_base (frame_info) + 8;
+ get_frame_saved_regs (frame_info)[DEPRECATED_FP_REGNUM] = get_frame_base (frame_info);
+ get_frame_saved_regs (frame_info)[PC_REGNUM] = get_frame_base (frame_info) + 4;
#ifdef SIG_SP_FP_OFFSET
/* Adjust saved SP_REGNUM for fake _sigtramp frames. */
- if (frame_info->signal_handler_caller && frame_info->next)
+ if ((get_frame_type (frame_info) == SIGTRAMP_FRAME) && frame_info->next)
frame_info->saved_regs[SP_REGNUM] =
frame_info->next->frame + SIG_SP_FP_OFFSET;
#endif
{
if ((regno == -1) || (regno == regi))
{
- *(regp + regi) = *(int *) ®isters[REGISTER_BYTE (regi)];
+ *(regp + regi) = *(int *) &deprecated_registers[REGISTER_BYTE (regi)];
}
}
if ((regno == -1) || (regno == PS_REGNUM))
{
- *(regp + R_PS) = *(int *) ®isters[REGISTER_BYTE (PS_REGNUM)];
+ *(regp + R_PS) = *(int *) &deprecated_registers[REGISTER_BYTE (PS_REGNUM)];
}
if ((regno == -1) || (regno == PC_REGNUM))
{
- *(regp + R_PC) = *(int *) ®isters[REGISTER_BYTE (PC_REGNUM)];
+ *(regp + R_PC) = *(int *) &deprecated_registers[REGISTER_BYTE (PC_REGNUM)];
}
}
register int regi;
char *from;
- for (regi = FP0_REGNUM; regi < FPC_REGNUM; regi++)
+ for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
{
from = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
supply_register (regi, from);
}
- supply_register (FPC_REGNUM, (char *) &(fpregsetp->f_pcr));
- supply_register (FPS_REGNUM, (char *) &(fpregsetp->f_psr));
- supply_register (FPI_REGNUM, (char *) &(fpregsetp->f_fpiaddr));
+ supply_register (M68K_FPC_REGNUM, (char *) &(fpregsetp->f_pcr));
+ supply_register (M68K_FPS_REGNUM, (char *) &(fpregsetp->f_psr));
+ supply_register (M68K_FPI_REGNUM, (char *) &(fpregsetp->f_fpiaddr));
}
/* Given a pointer to a floating point register set in /proc format
char *to;
char *from;
- for (regi = FP0_REGNUM; regi < FPC_REGNUM; regi++)
+ for (regi = FP0_REGNUM; regi < M68K_FPC_REGNUM; regi++)
{
if ((regno == -1) || (regno == regi))
{
- from = (char *) ®isters[REGISTER_BYTE (regi)];
+ from = (char *) &deprecated_registers[REGISTER_BYTE (regi)];
to = (char *) &(fpregsetp->f_fpregs[regi - FP0_REGNUM][0]);
memcpy (to, from, REGISTER_RAW_SIZE (regi));
}
}
- if ((regno == -1) || (regno == FPC_REGNUM))
+ if ((regno == -1) || (regno == M68K_FPC_REGNUM))
{
- fpregsetp->f_pcr = *(int *) ®isters[REGISTER_BYTE (FPC_REGNUM)];
+ fpregsetp->f_pcr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPC_REGNUM)];
}
- if ((regno == -1) || (regno == FPS_REGNUM))
+ if ((regno == -1) || (regno == M68K_FPS_REGNUM))
{
- fpregsetp->f_psr = *(int *) ®isters[REGISTER_BYTE (FPS_REGNUM)];
+ fpregsetp->f_psr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPS_REGNUM)];
}
- if ((regno == -1) || (regno == FPI_REGNUM))
+ if ((regno == -1) || (regno == M68K_FPI_REGNUM))
{
- fpregsetp->f_fpiaddr = *(int *) ®isters[REGISTER_BYTE (FPI_REGNUM)];
+ fpregsetp->f_fpiaddr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPI_REGNUM)];
}
}
we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
This routine returns true on success. */
-/* NOTE: cagney/2000-11-08: For this function to be fully multi-arched
- the macro's JB_PC and JB_ELEMENT_SIZE would need to be moved into
- the ``struct gdbarch_tdep'' object and then set on a target ISA/ABI
- dependant basis. */
-
int
m68k_get_longjmp_target (CORE_ADDR *pc)
{
-#if defined (JB_PC) && defined (JB_ELEMENT_SIZE)
char *buf;
CORE_ADDR sp, jb_addr;
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+ if (tdep->jb_pc < 0)
+ {
+ internal_error (__FILE__, __LINE__,
+ "m68k_get_longjmp_target: not implemented");
+ return 0;
+ }
buf = alloca (TARGET_PTR_BIT / TARGET_CHAR_BIT);
sp = read_register (SP_REGNUM);
jb_addr = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
- if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, buf,
+ if (target_read_memory (jb_addr + tdep->jb_pc * tdep->jb_elt_size, buf,
TARGET_PTR_BIT / TARGET_CHAR_BIT))
return 0;
*pc = extract_address (buf, TARGET_PTR_BIT / TARGET_CHAR_BIT);
-
return 1;
-#else
- internal_error (__FILE__, __LINE__,
- "m68k_get_longjmp_target: not implemented");
- return 0;
-#endif
}
/* Immediately after a function call, return the saved pc before the frame
system call, and if so, we know that Sun pushes the call # on the stack
prior to doing the trap. */
-CORE_ADDR
+static CORE_ADDR
m68k_saved_pc_after_call (struct frame_info *frame)
{
#ifdef SYSCALL_TRAP
int op;
- op = read_memory_integer (frame->pc - SYSCALL_TRAP_OFFSET, 2);
+ op = read_memory_unsigned_integer (frame->pc - SYSCALL_TRAP_OFFSET, 2);
if (op == SYSCALL_TRAP)
- return read_memory_integer (read_register (SP_REGNUM) + 4, 4);
+ return read_memory_unsigned_integer (read_register (SP_REGNUM) + 4, 4);
else
#endif /* SYSCALL_TRAP */
- return read_memory_integer (read_register (SP_REGNUM), 4);
+ return read_memory_unsigned_integer (read_register (SP_REGNUM), 4);
}
/* Function: m68k_gdbarch_init
if (arches != NULL)
return (arches->gdbarch);
-#if 0
- tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
-#endif
-
- gdbarch = gdbarch_alloc (&info, 0);
+ tdep = xmalloc (sizeof (struct gdbarch_tdep));
+ gdbarch = gdbarch_alloc (&info, tdep);
+
+ /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
+ ready to unwind the PC first (see frame.c:get_prev_frame()). */
+ set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
set_gdbarch_long_double_format (gdbarch, &floatformat_m68881_ext);
set_gdbarch_long_double_bit (gdbarch, 96);
set_gdbarch_function_start_offset (gdbarch, 0);
set_gdbarch_skip_prologue (gdbarch, m68k_skip_prologue);
- set_gdbarch_saved_pc_after_call (gdbarch, m68k_saved_pc_after_call);
+ set_gdbarch_deprecated_saved_pc_after_call (gdbarch, m68k_saved_pc_after_call);
+ set_gdbarch_breakpoint_from_pc (gdbarch, m68k_local_breakpoint_from_pc);
/* Stack grows down. */
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_stack_align (gdbarch, m68k_stack_align);
-
+ set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
set_gdbarch_decr_pc_after_break (gdbarch, 2);
- set_gdbarch_store_struct_return (gdbarch, m68k_store_struct_return);
+ set_gdbarch_deprecated_store_struct_return (gdbarch, m68k_store_struct_return);
set_gdbarch_deprecated_extract_return_value (gdbarch,
m68k_deprecated_extract_return_value);
- set_gdbarch_store_return_value (gdbarch, m68k_store_return_value);
+ set_gdbarch_deprecated_store_return_value (gdbarch, m68k_store_return_value);
- set_gdbarch_frame_chain (gdbarch, m68k_frame_chain);
- set_gdbarch_frame_chain_valid (gdbarch, generic_func_frame_chain_valid);
- set_gdbarch_frame_saved_pc (gdbarch, m68k_frame_saved_pc);
- set_gdbarch_frame_init_saved_regs (gdbarch, m68k_frame_init_saved_regs);
+ set_gdbarch_deprecated_frame_chain (gdbarch, m68k_frame_chain);
+ set_gdbarch_deprecated_frame_saved_pc (gdbarch, m68k_frame_saved_pc);
+ set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, m68k_frame_init_saved_regs);
set_gdbarch_frameless_function_invocation (gdbarch,
m68k_frameless_function_invocation);
/* OK to default this value to 'unknown'. */
set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
set_gdbarch_frame_args_skip (gdbarch, 8);
- set_gdbarch_frame_args_address (gdbarch, default_frame_address);
- set_gdbarch_frame_locals_address (gdbarch, default_frame_address);
set_gdbarch_register_raw_size (gdbarch, m68k_register_raw_size);
set_gdbarch_register_virtual_size (gdbarch, m68k_register_virtual_size);
- set_gdbarch_max_register_raw_size (gdbarch, 12);
- set_gdbarch_max_register_virtual_size (gdbarch, 12);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, 12);
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 12);
set_gdbarch_register_virtual_type (gdbarch, m68k_register_virtual_type);
set_gdbarch_register_name (gdbarch, m68k_register_name);
- set_gdbarch_register_size (gdbarch, 4);
+ set_gdbarch_deprecated_register_size (gdbarch, 4);
set_gdbarch_register_byte (gdbarch, m68k_register_byte);
set_gdbarch_num_regs (gdbarch, 29);
set_gdbarch_register_bytes_ok (gdbarch, m68k_register_bytes_ok);
- set_gdbarch_register_bytes (gdbarch, (16 * 4 + 8 + 8 * 12 + 3 * 4));
- set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
- set_gdbarch_fp_regnum (gdbarch, E_FP_REGNUM);
- set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
- set_gdbarch_ps_regnum (gdbarch, E_PS_REGNUM);
- set_gdbarch_fp0_regnum (gdbarch, E_FP0_REGNUM);
-
- set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+ set_gdbarch_deprecated_register_bytes (gdbarch, (16 * 4 + 8 + 8 * 12 + 3 * 4));
+ set_gdbarch_sp_regnum (gdbarch, M68K_SP_REGNUM);
+ set_gdbarch_deprecated_fp_regnum (gdbarch, M68K_FP_REGNUM);
+ set_gdbarch_pc_regnum (gdbarch, M68K_PC_REGNUM);
+ set_gdbarch_ps_regnum (gdbarch, M68K_PS_REGNUM);
+ set_gdbarch_fp0_regnum (gdbarch, M68K_FP0_REGNUM);
+
+ set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
- set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
- set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 24);
- set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
- set_gdbarch_call_dummy_p (gdbarch, 1);
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_call_dummy_length (gdbarch, 28);
- set_gdbarch_call_dummy_start_offset (gdbarch, 12);
-
- set_gdbarch_call_dummy_words (gdbarch, call_dummy_words);
- set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words));
- set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
- set_gdbarch_fix_call_dummy (gdbarch, m68k_fix_call_dummy);
- set_gdbarch_push_dummy_frame (gdbarch, m68k_push_dummy_frame);
- set_gdbarch_pop_frame (gdbarch, m68k_pop_frame);
+ set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 24);
+ set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
+ set_gdbarch_deprecated_call_dummy_length (gdbarch, 28);
+ set_gdbarch_deprecated_call_dummy_start_offset (gdbarch, 12);
+
+ set_gdbarch_deprecated_call_dummy_words (gdbarch, call_dummy_words);
+ set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (call_dummy_words));
+ set_gdbarch_deprecated_fix_call_dummy (gdbarch, m68k_fix_call_dummy);
+ set_gdbarch_deprecated_push_dummy_frame (gdbarch, m68k_push_dummy_frame);
+ set_gdbarch_deprecated_pop_frame (gdbarch, m68k_pop_frame);
+
+ /* Should be using push_dummy_call. */
+ set_gdbarch_deprecated_dummy_write_sp (gdbarch, generic_target_write_sp);
+
+#if defined JB_PC && defined JB_ELEMENT_SIZE
+ tdep->jb_pc = JB_PC;
+ tdep->jb_elt_size = JB_ELEMENT_SIZE;
+#else
+ tdep->jb_pc = -1;
+#endif
+
+ /* Hook in ABI-specific overrides, if they have been registered. */
+ gdbarch_init_osabi (info, gdbarch);
+
+ /* Now we have tuned the configuration, set a few final things,
+ based on what the OS ABI has told us. */
+
+ if (tdep->jb_pc >= 0)
+ set_gdbarch_get_longjmp_target (gdbarch, m68k_get_longjmp_target);
return gdbarch;
}
static void
m68k_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
{
+ struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+ if (tdep == NULL)
+ return;
}
void
_initialize_m68k_tdep (void)
{
gdbarch_register (bfd_arch_m68k, m68k_gdbarch_init, m68k_dump_tdep);
- tm_print_insn = print_insn_m68k;
+ deprecated_tm_print_insn = print_insn_m68k;
}
projects / deliverable / binutils-gdb.git / blobdiff