[deliverable/binutils-gdb.git] / gdb / m68k-tdep.c

/* Target dependent code for the Motorola 68000 series.
   Copyright (C) 1990, 1992 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
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include "defs.h"
#include "ieee-float.h"
#include "frame.h"
#include "symtab.h"

const struct ext_format ext_format_68881 = {
/* tot sbyte smask expbyte manbyte */
   12, 0,    0x80, 0,1,	   4,8		/* mc68881 */
};

\f
/* Things needed for making the inferior call functions.
   It seems like every m68k based machine has almost identical definitions
   in the individual machine's configuration files.  Most other cpu types
   (mips, i386, etc) have routines in their *-tdep.c files to handle this
   for most configurations.  The m68k family should be able to do this as
   well.  These macros can still be overridden when necessary.  */

/* Push an empty stack frame, to record the current PC, etc.  */

void
m68k_push_dummy_frame ()
{
  register CORE_ADDR sp = read_register (SP_REGNUM);
  register int 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);
#if defined (HAVE_68881)
  for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
    {
      read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
      sp = push_bytes (sp, raw_buffer, 12);
    }
#endif
  for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
    {
      sp = push_word (sp, read_register (regnum));
    }
  sp = push_word (sp, read_register (PS_REGNUM));
  write_register (SP_REGNUM, sp);
}

/* Discard from the stack the innermost frame,
   restoring all saved registers.  */

void
m68k_pop_frame ()
{
  register FRAME frame = get_current_frame ();
  register CORE_ADDR fp;
  register int regnum;
  struct frame_saved_regs fsr;
  struct frame_info *fi;
  char raw_buffer[12];

  fi = get_frame_info (frame);
  fp = fi -> frame;
  get_frame_saved_regs (fi, &fsr);
#if defined (HAVE_68881)
  for (regnum = FP0_REGNUM + 7 ; regnum >= FP0_REGNUM ; regnum--)
    {
      if (fsr.regs[regnum])
	{
	  read_memory (fsr.regs[regnum], raw_buffer, 12);
	  write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
	}
    }
#endif
  for (regnum = FP_REGNUM - 1 ; regnum >= 0 ; regnum--)
    {
      if (fsr.regs[regnum])
	{
	  write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
	}
    }
  if (fsr.regs[PS_REGNUM])
    {
      write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4));
    }
  write_register (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 ();
  set_current_frame (create_new_frame (read_register (FP_REGNUM),
				       read_pc ()));
}

\f
/* Given an ip value corresponding to the start of a function,
   return the ip of the first instruction after the function 
   prologue.  This is the generic m68k support.  Machines which
   require something different can override the SKIP_PROLOGUE
   macro to point elsewhere.

   Some instructions which typically may appear in a function
   prologue include:

   A link instruction, word form:

	link.w	%a6,&0			4e56  XXXX

   A link instruction, long form:

	link.l  %fp,&F%1		480e  XXXX  XXXX

   A movm instruction to preserve integer regs:

	movm.l  &M%1,(4,%sp)		48ef  XXXX  XXXX

   A fmovm instruction to preserve float regs:

	fmovm   &FPM%1,(FPO%1,%sp)	f237  XXXX  XXXX  XXXX  XXXX

   Some profiling setup code (FIXME, not recognized yet):

	lea.l   (.L3,%pc),%a1		43fb  XXXX  XXXX  XXXX
	bsr     _mcount			61ff  XXXX  XXXX

  */

#define P_LINK_L	0x480e
#define P_LINK_W	0x4e56
#define P_MOV_L		0x207c
#define P_JSR		0x4eb9
#define P_BSR		0x61ff
#define P_LEA_L		0x43fb
#define P_MOVM_L	0x48ef
#define P_FMOVM		0xf237
#define P_TRAP		0x4e40

CORE_ADDR
m68k_skip_prologue (ip)
CORE_ADDR ip;
{
  register CORE_ADDR limit;
  struct symtab_and_line sal;
  register int op;

  /* Find out if there is a known limit for the extent of the prologue.
     If so, ensure we don't go past it.  If not, assume "infinity". */

  sal = find_pc_line (ip, 0);
  limit = (sal.end) ? sal.end : (CORE_ADDR) ~0;

  while (ip < limit)
    {
      op = read_memory_integer (ip, 2);
      op &= 0xFFFF;
      
      if (op == P_LINK_W)
	{
	  ip += 4;	/* Skip link.w */
	}
      else if (op == P_LINK_L)
	{
	  ip += 6;	/* Skip link.l */
	}
      else if (op == P_MOVM_L)
	{
	  ip += 6;	/* Skip movm.l */
	}
      else if (op == P_FMOVM)
	{
	  ip += 10;	/* Skip fmovm */
	}
      else
	{
	  break;	/* Found unknown code, bail out. */
	}
    }
  return (ip);
}

#ifdef USE_PROC_FS	/* Target dependent support for /proc */

#include <sys/procfs.h>

/*  The /proc interface divides the target machine's register set up into
    two different sets, the general register set (gregset) and the floating
    point register set (fpregset).  For each set, there is an ioctl to get
    the current register set and another ioctl to set the current values.

    The actual structure passed through the ioctl interface is, of course,
    naturally machine dependent, and is different for each set of registers.
    For the m68k for example, the general register set is typically defined
    by:

	typedef int gregset_t[18];

	#define	R_D0	0
	...
	#define	R_PS	17

    and the floating point set by:

    	typedef	struct fpregset {
	  int	f_pcr;
	  int	f_psr;
	  int	f_fpiaddr;
	  int	f_fpregs[8][3];		(8 regs, 96 bits each)
	} fpregset_t;

    These routines provide the packing and unpacking of gregset_t and
    fpregset_t formatted data.

 */


/*  Given a pointer to a general register set in /proc format (gregset_t *),
    unpack the register contents and supply them as gdb's idea of the current
    register values. */

void
supply_gregset (gregsetp)
gregset_t *gregsetp;
{
  register int regi;
  register greg_t *regp = (greg_t *) gregsetp;

  for (regi = 0 ; regi < R_PC ; regi++)
    {
      supply_register (regi, (char *) (regp + regi));
    }
  supply_register (PS_REGNUM, (char *) (regp + R_PS));
  supply_register (PC_REGNUM, (char *) (regp + R_PC));
}

void
fill_gregset (gregsetp, regno)
gregset_t *gregsetp;
int regno;
{
  register int regi;
  register greg_t *regp = (greg_t *) gregsetp;
  extern char registers[];

  for (regi = 0 ; regi < R_PC ; regi++)
    {
      if ((regno == -1) || (regno == regi))
	{
	  *(regp + regi) = *(int *) &registers[REGISTER_BYTE (regi)];
	}
    }
  if ((regno == -1) || (regno == PS_REGNUM))
    {
      *(regp + R_PS) = *(int *) &registers[REGISTER_BYTE (PS_REGNUM)];
    }
  if ((regno == -1) || (regno == PC_REGNUM))
    {
      *(regp + R_PC) = *(int *) &registers[REGISTER_BYTE (PC_REGNUM)];
    }
}

#if defined (FP0_REGNUM)

/*  Given a pointer to a floating point register set in /proc format
    (fpregset_t *), unpack the register contents and supply them as gdb's
    idea of the current floating point register values. */

void 
supply_fpregset (fpregsetp)
fpregset_t *fpregsetp;
{
  register int regi;
  char *from;
  
  for (regi = FP0_REGNUM ; regi < 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));
}

/*  Given a pointer to a floating point register set in /proc format
    (fpregset_t *), update the register specified by REGNO from gdb's idea
    of the current floating point register set.  If REGNO is -1, update
    them all. */

void
fill_fpregset (fpregsetp, regno)
fpregset_t *fpregsetp;
int regno;
{
  int regi;
  char *to;
  char *from;
  extern char registers[];

  for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++)
    {
      if ((regno == -1) || (regno == regi))
	{
	  from = (char *) &registers[REGISTER_BYTE (regi)];
	  to = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]);
	  bcopy (from, to, REGISTER_RAW_SIZE (regi));
	}
    }
  if ((regno == -1) || (regno == FPC_REGNUM))
    {
      fpregsetp -> f_pcr = *(int *) &registers[REGISTER_BYTE (FPC_REGNUM)];
    }
  if ((regno == -1) || (regno == FPS_REGNUM))
    {
      fpregsetp -> f_psr = *(int *) &registers[REGISTER_BYTE (FPS_REGNUM)];
    }
  if ((regno == -1) || (regno == FPI_REGNUM))
    {
      fpregsetp -> f_fpiaddr = *(int *) &registers[REGISTER_BYTE (FPI_REGNUM)];
    }
}

#endif	/* defined (FP0_REGNUM) */

#endif  /* USE_PROC_FS */

#ifdef GET_LONGJMP_TARGET
/* Figure out where the longjmp will land.  Slurp the args out of the stack.
   We expect the first arg to be a pointer to the jmp_buf structure from which
   we extract the pc (JB_PC) that we will land at.  The pc is copied into PC.
   This routine returns true on success. */

int
get_longjmp_target(pc)
     CORE_ADDR *pc;
{
  CORE_ADDR sp, jb_addr;

  sp = read_register(SP_REGNUM);

  if (target_read_memory(sp + SP_ARG0, /* Offset of first arg on stack */
			 &jb_addr,
			 sizeof(CORE_ADDR)))
    return 0;


  SWAP_TARGET_AND_HOST(&jb_addr, sizeof(CORE_ADDR));

  if (target_read_memory(jb_addr + JB_PC * JB_ELEMENT_SIZE, pc,
			 sizeof(CORE_ADDR)))
    return 0;

  SWAP_TARGET_AND_HOST(pc, sizeof(CORE_ADDR));

  return 1;
}
#endif /* GET_LONGJMP_TARGET */

/* Immediately after a function call, return the saved pc before the frame
   is setup.  We check for the common case of being inside of a system call,
   and if so, we know that Sun pushes the call # on the stack prior to doing
   the trap. */

CORE_ADDR
m68k_saved_pc_after_call(frame)
     struct frame_info *frame;
{
#ifdef sun
  int op;

  op = read_memory_integer (frame->pc, 2);
  op &= 0xFFFF;

  if (op == P_TRAP)
    return read_memory_integer (read_register (SP_REGNUM) + 4, 4);
  else
#endif /* sun */
    return read_memory_integer (read_register (SP_REGNUM), 4);
}
Commit	Line	Data
bd5635a1	1	/* Target dependent code for the Motorola 68000 series.
f4992534	2	Copyright (C) 1990, 1992 Free Software Foundation, Inc.
bd5635a1 RP	3
	4	This file is part of GDB.
	5
b6666a5d	6	This program is free software; you can redistribute it and/or modify
bd5635a1	7	it under the terms of the GNU General Public License as published by
b6666a5d FF	8	the Free Software Foundation; either version 2 of the License, or
b6666a5d FF	9	(at your option) any later version.
bd5635a1	10
b6666a5d	11	This program is distributed in the hope that it will be useful,
bd5635a1 RP	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
b6666a5d FF	17	along with this program; if not, write to the Free Software
b6666a5d FF	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
bd5635a1 RP	19
	20	#include "defs.h"
	21	#include "ieee-float.h"
b6666a5d FF	22	#include "frame.h"
b6666a5d FF	23	#include "symtab.h"
bd5635a1	24
b6666a5d	25	const struct ext_format ext_format_68881 = {
bd5635a1	26	/* tot sbyte smask expbyte manbyte */
b6666a5d	27	12, 0, 0x80, 0,1, 4,8 /* mc68881 */
bd5635a1	28	};
b6666a5d FF	29
	30	\f
	31	/* Things needed for making the inferior call functions.
	32	It seems like every m68k based machine has almost identical definitions
	33	in the individual machine's configuration files. Most other cpu types
	34	(mips, i386, etc) have routines in their *-tdep.c files to handle this
	35	for most configurations. The m68k family should be able to do this as
	36	well. These macros can still be overridden when necessary. */
	37
	38	/* Push an empty stack frame, to record the current PC, etc. */
	39
	40	void
	41	m68k_push_dummy_frame ()
	42	{
	43	register CORE_ADDR sp = read_register (SP_REGNUM);
	44	register int regnum;
	45	char raw_buffer[12];
	46
	47	sp = push_word (sp, read_register (PC_REGNUM));
	48	sp = push_word (sp, read_register (FP_REGNUM));
	49	write_register (FP_REGNUM, sp);
	50	#if defined (HAVE_68881)
	51	for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--)
	52	{
	53	read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
	54	sp = push_bytes (sp, raw_buffer, 12);
	55	}
	56	#endif
	57	for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--)
	58	{
	59	sp = push_word (sp, read_register (regnum));
	60	}
	61	sp = push_word (sp, read_register (PS_REGNUM));
	62	write_register (SP_REGNUM, sp);
	63	}
	64
	65	/* Discard from the stack the innermost frame,
	66	restoring all saved registers. */
	67
	68	void
	69	m68k_pop_frame ()
	70	{
	71	register FRAME frame = get_current_frame ();
	72	register CORE_ADDR fp;
	73	register int regnum;
	74	struct frame_saved_regs fsr;
	75	struct frame_info *fi;
	76	char raw_buffer[12];
	77
	78	fi = get_frame_info (frame);
	79	fp = fi -> frame;
	80	get_frame_saved_regs (fi, &fsr);
	81	#if defined (HAVE_68881)
	82	for (regnum = FP0_REGNUM + 7 ; regnum >= FP0_REGNUM ; regnum--)
	83	{
	84	if (fsr.regs[regnum])
	85	{
	86	read_memory (fsr.regs[regnum], raw_buffer, 12);
	87	write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12);
	88	}
	89	}
	90	#endif
	91	for (regnum = FP_REGNUM - 1 ; regnum >= 0 ; regnum--)
	92	{
93	if (fsr.regs[regnum])
94	{
95	write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
96	}
97	}
98	if (fsr.regs[PS_REGNUM])
99	{
100	write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4));
101	}
102	write_register (FP_REGNUM, read_memory_integer (fp, 4));
103	write_register (PC_REGNUM, read_memory_integer (fp + 4, 4));
104	write_register (SP_REGNUM, fp + 8);
105	flush_cached_frames ();
106	set_current_frame (create_new_frame (read_register (FP_REGNUM),
107	read_pc ()));
108	}
109
110	\f
111	/* Given an ip value corresponding to the start of a function,
112	return the ip of the first instruction after the function
113	prologue. This is the generic m68k support. Machines which
114	require something different can override the SKIP_PROLOGUE
115	macro to point elsewhere.
116
117	Some instructions which typically may appear in a function
118	prologue include:
119
120	A link instruction, word form:
121
122	link.w %a6,&0 4e56 XXXX
123
124	A link instruction, long form:
125
126	link.l %fp,&F%1 480e XXXX XXXX
127
128	A movm instruction to preserve integer regs:
129
130	movm.l &M%1,(4,%sp) 48ef XXXX XXXX
131
132	A fmovm instruction to preserve float regs:
133
134	fmovm &FPM%1,(FPO%1,%sp) f237 XXXX XXXX XXXX XXXX
135
136	Some profiling setup code (FIXME, not recognized yet):
137
138	lea.l (.L3,%pc),%a1 43fb XXXX XXXX XXXX
139	bsr _mcount 61ff XXXX XXXX
140
141	*/
142
143	#define P_LINK_L 0x480e
144	#define P_LINK_W 0x4e56
145	#define P_MOV_L 0x207c
146	#define P_JSR 0x4eb9
147	#define P_BSR 0x61ff
148	#define P_LEA_L 0x43fb
149	#define P_MOVM_L 0x48ef
150	#define P_FMOVM 0xf237
f4992534	151	#define P_TRAP 0x4e40
b6666a5d FF	152
	153	CORE_ADDR
	154	m68k_skip_prologue (ip)
	155	CORE_ADDR ip;
	156	{
	157	register CORE_ADDR limit;
	158	struct symtab_and_line sal;
	159	register int op;
	160
	161	/* Find out if there is a known limit for the extent of the prologue.
	162	If so, ensure we don't go past it. If not, assume "infinity". */
	163
	164	sal = find_pc_line (ip, 0);
	165	limit = (sal.end) ? sal.end : (CORE_ADDR) ~0;
	166
	167	while (ip < limit)
	168	{
	169	op = read_memory_integer (ip, 2);
	170	op &= 0xFFFF;
	171
	172	if (op == P_LINK_W)
	173	{
	174	ip += 4; /* Skip link.w */
	175	}
	176	else if (op == P_LINK_L)
	177	{
	178	ip += 6; /* Skip link.l */
	179	}
	180	else if (op == P_MOVM_L)
	181	{
	182	ip += 6; /* Skip movm.l */
	183	}
	184	else if (op == P_FMOVM)
	185	{
	186	ip += 10; /* Skip fmovm */
	187	}
	188	else
	189	{
	190	break; /* Found unknown code, bail out. */
	191	}
	192	}
	193	return (ip);
	194	}
	195
	196	#ifdef USE_PROC_FS /* Target dependent support for /proc */
	197
	198	#include <sys/procfs.h>
	199
	200	/* The /proc interface divides the target machine's register set up into
	201	two different sets, the general register set (gregset) and the floating
	202	point register set (fpregset). For each set, there is an ioctl to get
	203	the current register set and another ioctl to set the current values.
	204
	205	The actual structure passed through the ioctl interface is, of course,
	206	naturally machine dependent, and is different for each set of registers.
	207	For the m68k for example, the general register set is typically defined
	208	by:
	209
	210	typedef int gregset_t[18];
	211
	212	#define R_D0 0
	213	...
	214	#define R_PS 17
	215
216	and the floating point set by:
217
218	typedef struct fpregset {
219	int f_pcr;
220	int f_psr;
221	int f_fpiaddr;
222	int f_fpregs[8][3]; (8 regs, 96 bits each)
223	} fpregset_t;
224
225	These routines provide the packing and unpacking of gregset_t and
226	fpregset_t formatted data.
227
228	*/
229
230
231	/* Given a pointer to a general register set in /proc format (gregset_t *),
232	unpack the register contents and supply them as gdb's idea of the current
233	register values. */
234
235	void
236	supply_gregset (gregsetp)
237	gregset_t *gregsetp;
238	{
f4992534	239	register int regi;
b6666a5d FF	240	register greg_t regp = (greg_t ) gregsetp;
b6666a5d FF	241
f4992534	242	for (regi = 0 ; regi < R_PC ; regi++)
b6666a5d	243	{
f4992534	244	supply_register (regi, (char *) (regp + regi));
b6666a5d FF	245	}
	246	supply_register (PS_REGNUM, (char *) (regp + R_PS));
	247	supply_register (PC_REGNUM, (char *) (regp + R_PC));
	248	}
	249
	250	void
	251	fill_gregset (gregsetp, regno)
	252	gregset_t *gregsetp;
	253	int regno;
	254	{
f4992534	255	register int regi;
b6666a5d FF	256	register greg_t regp = (greg_t ) gregsetp;
	257	extern char registers[];
	258
	259	for (regi = 0 ; regi < R_PC ; regi++)
	260	{
	261	if ((regno == -1) \|\| (regno == regi))
	262	{
f4992534	263	(regp + regi) = (int *) &registers[REGISTER_BYTE (regi)];
b6666a5d FF	264	}
	265	}
	266	if ((regno == -1) \|\| (regno == PS_REGNUM))
	267	{
	268	(regp + R_PS) = (int *) &registers[REGISTER_BYTE (PS_REGNUM)];
	269	}
	270	if ((regno == -1) \|\| (regno == PC_REGNUM))
	271	{
	272	(regp + R_PC) = (int *) &registers[REGISTER_BYTE (PC_REGNUM)];
	273	}
	274	}
	275
	276	#if defined (FP0_REGNUM)
	277
	278	/* Given a pointer to a floating point register set in /proc format
	279	(fpregset_t *), unpack the register contents and supply them as gdb's
	280	idea of the current floating point register values. */
	281
	282	void
	283	supply_fpregset (fpregsetp)
	284	fpregset_t *fpregsetp;
	285	{
f4992534 SG	286	register int regi;
f4992534 SG	287	char *from;
b6666a5d	288
f4992534	289	for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++)
b6666a5d	290	{
f4992534 SG	291	from = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]);
f4992534 SG	292	supply_register (regi, from);
b6666a5d FF	293	}
	294	supply_register (FPC_REGNUM, (char *) &(fpregsetp -> f_pcr));
	295	supply_register (FPS_REGNUM, (char *) &(fpregsetp -> f_psr));
	296	supply_register (FPI_REGNUM, (char *) &(fpregsetp -> f_fpiaddr));
	297	}
	298
	299	/* Given a pointer to a floating point register set in /proc format
	300	(fpregset_t *), update the register specified by REGNO from gdb's idea
	301	of the current floating point register set. If REGNO is -1, update
	302	them all. */
	303
	304	void
	305	fill_fpregset (fpregsetp, regno)
	306	fpregset_t *fpregsetp;
	307	int regno;
	308	{
	309	int regi;
	310	char *to;
	311	char *from;
	312	extern char registers[];
	313
	314	for (regi = FP0_REGNUM ; regi < FPC_REGNUM ; regi++)
	315	{
	316	if ((regno == -1) \|\| (regno == regi))
	317	{
	318	from = (char *) &registers[REGISTER_BYTE (regi)];
f4992534 SG	319	to = (char *) &(fpregsetp -> f_fpregs[regi-FP0_REGNUM][0]);
f4992534 SG	320	bcopy (from, to, REGISTER_RAW_SIZE (regi));
b6666a5d FF	321	}
	322	}
	323	if ((regno == -1) \|\| (regno == FPC_REGNUM))
	324	{
	325	fpregsetp -> f_pcr = (int ) &registers[REGISTER_BYTE (FPC_REGNUM)];
	326	}
	327	if ((regno == -1) \|\| (regno == FPS_REGNUM))
	328	{
	329	fpregsetp -> f_psr = (int ) &registers[REGISTER_BYTE (FPS_REGNUM)];
	330	}
	331	if ((regno == -1) \|\| (regno == FPI_REGNUM))
	332	{
	333	fpregsetp -> f_fpiaddr = (int ) &registers[REGISTER_BYTE (FPI_REGNUM)];
	334	}
	335	}
	336
	337	#endif /* defined (FP0_REGNUM) */
	338
	339	#endif /* USE_PROC_FS */
f4992534 SG	340
	341	#ifdef GET_LONGJMP_TARGET
	342	/* Figure out where the longjmp will land. Slurp the args out of the stack.
	343	We expect the first arg to be a pointer to the jmp_buf structure from which
	344	we extract the pc (JB_PC) that we will land at. The pc is copied into PC.
	345	This routine returns true on success. */
	346
	347	int
	348	get_longjmp_target(pc)
	349	CORE_ADDR *pc;
	350	{
	351	CORE_ADDR sp, jb_addr;
	352
	353	sp = read_register(SP_REGNUM);
	354
	355	if (target_read_memory(sp + SP_ARG0, /* Offset of first arg on stack */
	356	&jb_addr,
	357	sizeof(CORE_ADDR)))
	358	return 0;
	359
	360
	361	SWAP_TARGET_AND_HOST(&jb_addr, sizeof(CORE_ADDR));
	362
	363	if (target_read_memory(jb_addr + JB_PC * JB_ELEMENT_SIZE, pc,
	364	sizeof(CORE_ADDR)))
	365	return 0;
	366
	367	SWAP_TARGET_AND_HOST(pc, sizeof(CORE_ADDR));
	368
	369	return 1;
	370	}
	371	#endif /* GET_LONGJMP_TARGET */
	372
	373	/* Immediately after a function call, return the saved pc before the frame
	374	is setup. We check for the common case of being inside of a system call,
	375	and if so, we know that Sun pushes the call # on the stack prior to doing
	376	the trap. */
	377
	378	CORE_ADDR
	379	m68k_saved_pc_after_call(frame)
	380	struct frame_info *frame;
	381	{
	382	#ifdef sun
	383	int op;
	384
	385	op = read_memory_integer (frame->pc, 2);
	386	op &= 0xFFFF;
	387
	388	if (op == P_TRAP)
	389	return read_memory_integer (read_register (SP_REGNUM) + 4, 4);
	390	else
	391	#endif /* sun */
	392	return read_memory_integer (read_register (SP_REGNUM), 4);
	393	}