/* 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 "m68k-tdep.h"
\f
#define P_LINKL_FP 0x480e
#define P_TRAP 0x4e40
-/* Register numbers of various important registers.
- Note that some of these values are "real" register numbers,
- and correspond to the general registers of the machine,
- and some are "phony" register numbers which are too large
- to be actual register numbers as far as the user is concerned
- but do serve to get the desired values when passed to read_register. */
-
-/* Note: Since they are used in files other than this (monitor files),
- D0_REGNUM and A0_REGNUM are currently defined in tm-m68k.h. */
-
-enum
-{
- E_A1_REGNUM = 9,
- 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 */
- E_FPC_REGNUM = 26, /* 68881 control register */
- E_FPS_REGNUM = 27, /* 68881 status register */
- E_FPI_REGNUM = 28
-};
-
#define REGISTER_BYTES_FP (16*4 + 8 + 8*12 + 3*4)
#define REGISTER_BYTES_NOFP (16*4 + 8)
return (((unsigned) (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 >= E_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 >= E_FPC_REGNUM)
- return (((regnum - E_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 (E_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
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);
}
extern CORE_ADDR
altos_skip_prologue (CORE_ADDR pc)
{
- register int op = read_memory_integer (pc, 2);
+ register int op = read_memory_unsigned_integer (pc, 2);
if (op == P_LINKW_FP)
pc += 4; /* Skip link #word */
else if (op == P_LINKL_FP)
{
/* 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 read_memory_unsigned_integer (delta68_frame_args_address (frame_info)
+ + 4, 4);
}
/* Return number of args passed to a frame.
{
int val;
CORE_ADDR pc = FRAME_SAVED_PC (fi);
- int insn = 0177777 & read_memory_integer (pc, 2);
+ 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);
{
int val;
CORE_ADDR pc = FRAME_SAVED_PC (fi);
- int insn = 0177777 & read_memory_integer (pc, 2);
+ 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);
{
int val;
CORE_ADDR pc = FRAME_SAVED_PC (fi);
- int insn = 0177777 & read_memory_integer (pc, 2);
+ 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);
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);
}
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--)
{
- 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 (PC_REGNUM, read_memory_integer (fp + 4, 4));
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 */
/* 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 - 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_pc_function_start (get_frame_pc (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)[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 < E_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 (E_FPC_REGNUM, (char *) &(fpregsetp->f_pcr));
- supply_register (E_FPS_REGNUM, (char *) &(fpregsetp->f_psr));
- supply_register (E_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 < E_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 == E_FPC_REGNUM))
+ if ((regno == -1) || (regno == M68K_FPC_REGNUM))
{
- fpregsetp->f_pcr = *(int *) ®isters[REGISTER_BYTE (E_FPC_REGNUM)];
+ fpregsetp->f_pcr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPC_REGNUM)];
}
- if ((regno == -1) || (regno == E_FPS_REGNUM))
+ if ((regno == -1) || (regno == M68K_FPS_REGNUM))
{
- fpregsetp->f_psr = *(int *) ®isters[REGISTER_BYTE (E_FPS_REGNUM)];
+ fpregsetp->f_psr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPS_REGNUM)];
}
- if ((regno == -1) || (regno == E_FPI_REGNUM))
+ if ((regno == -1) || (regno == M68K_FPI_REGNUM))
{
- fpregsetp->f_fpiaddr = *(int *) ®isters[REGISTER_BYTE (E_FPI_REGNUM)];
+ fpregsetp->f_fpiaddr = *(int *) &deprecated_registers[REGISTER_BYTE (M68K_FPI_REGNUM)];
}
}
#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
gdbarch = gdbarch_alloc (&info, 0);
+ /* 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_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_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_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_sp_regnum (gdbarch, M68K_SP_REGNUM);
+ set_gdbarch_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_use_generic_dummy_frames (gdbarch, 0);
+ 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_deprecated_pc_in_call_dummy (gdbarch, deprecated_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_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_deprecated_push_dummy_frame (gdbarch, m68k_push_dummy_frame);
set_gdbarch_pop_frame (gdbarch, m68k_pop_frame);
return gdbarch;