/* Parameters for execution on a 68000 series machine.
- Copyright (C) 1986, 1987, 1989, 1990 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1990, 1992 Free Software Foundation, Inc.
This file is part of GDB.
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-/* Generic 68000 stuff, to be included by other m-*.h files.
+/* Generic 68000 stuff, to be included by other tm-*.h files.
Define HAVE_68881 if that is the case. */
#if defined (HAVE_68881)
/* Advance PC across any function entry prologue instructions
to reach some "real" code. */
-#define SKIP_PROLOGUE(pc) \
-{ register int op = read_memory_integer (pc, 2); \
- if (op == 0047126) \
- pc += 4; /* Skip link #word */ \
- else if (op == 0044016) \
- pc += 6; /* Skip link #long */ \
- /* Not sure why branches are here. */ \
- /* From m-isi.h, m-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 */ \
-}
+#if !defined(SKIP_PROLOGUE)
+#define SKIP_PROLOGUE(ip) {(ip) = m68k_skip_prologue(ip);}
+extern CORE_ADDR m68k_skip_prologue PARAMS ((CORE_ADDR ip));
+#endif
/* Immediately after a function call, return the saved pc.
Can't always go through the frames for this because on some machines
/* Sequence of bytes for breakpoint instruction.
This is a TRAP instruction. The last 4 bits (0xf below) is the
- vector. Systems which don't use 0xf should define BREAKPOINT
+ vector. Systems which don't use 0xf should define BPT_VECTOR
themselves before including this file. */
+#if !defined (BPT_VECTOR)
+#define BPT_VECTOR 0xf
+#endif
+
#if !defined (BREAKPOINT)
-#define BREAKPOINT {0x4e, 0x4f}
+#define BREAKPOINT {0x4e, (0x40 | BPT_VECTOR)}
#endif
/* If your kernel resets the pc after the trap happens you may need to
/* Put the declaration out here because if it's in the macros, PCC
will complain. */
-extern struct ext_format ext_format_68881;
+extern const struct ext_format ext_format_68881;
/* Convert data from raw format for register REGNUM
to virtual format for register REGNUM. */
if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
ieee_extended_to_double (&ext_format_68881, (FROM), (double *)(TO)); \
else \
- bcopy ((FROM), (TO), 4); \
+ memcpy ((TO), (FROM), 4); \
}
/* Convert data from virtual format for register REGNUM
if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \
double_to_ieee_extended (&ext_format_68881, (double *)(FROM), (TO)); \
else \
- bcopy ((FROM), (TO), 4); \
+ memcpy ((TO), (FROM), 4); \
}
/* Return the GDB type object for the "standard" data type
/* Convert data from raw format for register REGNUM
to virtual format for register REGNUM. */
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) bcopy ((FROM), (TO), 4);
+#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) memcpy ((TO), (FROM), 4);
/* Convert data from virtual format for register REGNUM
to raw format for register REGNUM. */
-#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) bcopy ((FROM), (TO), 4);
+#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) memcpy ((TO), (FROM), 4);
/* Return the GDB type object for the "standard" data type
of data in register N. */
#if !defined (EXTRACT_RETURN_VALUE)
#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
- bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE))
+ memcpy ((VALBUF), \
+ (char *)(REGBUF) + \
+ (TYPE_LENGTH(TYPE) >= 4 ? 0 : 4 - TYPE_LENGTH(TYPE)), \
+ TYPE_LENGTH(TYPE))
#endif
/* Write into appropriate registers a function return value
/* 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.
-
- FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
- and produces the nominal address of the caller frame.
-
- However, if FRAME_CHAIN_VALID returns zero,
- it means the given frame is the outermost one and has no caller.
- In that case, FRAME_CHAIN_COMBINE is not used. */
-
-/* In the case of the 68000, the frame's nominal address
+/* 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. */
#define FRAME_CHAIN(thisframe) \
- (outside_startup_file ((thisframe)->pc) ? \
+ (!inside_entry_file ((thisframe)->pc) ? \
read_memory_integer ((thisframe)->frame, 4) :\
0)
-#define FRAME_CHAIN_VALID(chain, thisframe) \
- (chain != 0 && outside_startup_file (FRAME_SAVED_PC (thisframe)))
-
-#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
-
/* Define other aspects of the stack frame. */
/* A macro that tells us whether the function invocation represented
for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) \
if (regmask & 1) \
(frame_saved_regs).regs[regnum] = (next_addr -= 4); } \
- else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2)) \
+ else if (0x2f00 == (0xfff0 & read_memory_integer (pc, 2))) \
{ regnum = 0xf & read_memory_integer (pc, 2); pc += 2; \
(frame_saved_regs).regs[regnum] = (next_addr -= 4); } \
/* clrw -(sp); movw ccr,-(sp) may follow. */ \
for most configurations. The m68k family should be able to do this as
well. These macros can still be overridden when necessary. */
-/* The CALL_DUMMY macro is the sequence of instructions
- fmovem 0xff,-(sp)
- moveml 0xfffc,-(sp)
- clrw -(sp)
- movew ccr,-(sp)
- /..* The arguments are pushed at this point by GDB;
+/* The CALL_DUMMY macro is the sequence of instructions, as disassembled
+ by gdb itself:
+
+ fmovemx fp0-fp7,sp@- 0xf227 0xe0ff
+ moveml d0-a5,sp@- 0x48e7 0xfffc
+ clrw sp@- 0x4267
+ movew ccr,sp@- 0x42e7
+
+ /..* The arguments are pushed at this point by GDB;
no code is needed in the dummy for this.
The CALL_DUMMY_START_OFFSET gives the position of
the following jsr instruction. *../
- jsr @#32323232
- addl #69696969,sp
- bpt
- nop
-Note this is 28 bytes.
-We actually start executing at the jsr, since the pushing of the
-registers is done by PUSH_DUMMY_FRAME. If this were real code,
-the arguments for the function called by the jsr would be pushed
-between the moveml and the jsr, and we could allow it to execute through.
-But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done,
-and we cannot allow the moveml to push the registers again lest they be
-taken for the arguments. */
-#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e414e71}
+ jsr @#0x32323232 0x4eb9 0x3232 0x3232
+ addal #0x69696969,sp 0xdffc 0x6969 0x6969
+ trap #<your BPT_VECTOR number here> 0x4e4?
+ nop 0x4e71
+
+ Note this is CALL_DUMMY_LENGTH bytes (28 for the above example).
+ We actually start executing at the jsr, since the pushing of the
+ registers is done by PUSH_DUMMY_FRAME. If this were real code,
+ the arguments for the function called by the jsr would be pushed
+ between the moveml and the jsr, and we could allow it to execute through.
+ But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is
+ done, and we cannot allow the moveml to push the registers again lest
+ they be taken for the arguments. */
+
+#if defined (HAVE_68881)
+
+#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, (0x4e404e71 | (BPT_VECTOR << 16))}
+#define CALL_DUMMY_LENGTH 28 /* Size of CALL_DUMMY */
+#define CALL_DUMMY_START_OFFSET 12 /* Offset to jsr instruction*/
+
+#else
-#define CALL_DUMMY_LENGTH 28
+#define CALL_DUMMY {0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, (0x4e404e71 | (BPT_VECTOR << 16))}
+#define CALL_DUMMY_LENGTH 24 /* Size of CALL_DUMMY */
+#define CALL_DUMMY_START_OFFSET 8 /* Offset to jsr instruction*/
-#define CALL_DUMMY_START_OFFSET 12
+#endif /* HAVE_68881 */
/* Insert the specified number of args and function address
- into a call sequence of the above form stored at DUMMYNAME. */
+ 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. */
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
-{ *(int *)((char *) dummyname + 20) = nargs * 4; \
- *(int *)((char *) dummyname + 14) = fun; }
+{ _do_putb32 (fun, (char *) dummyname + CALL_DUMMY_START_OFFSET + 2); \
+ _do_putb32 (nargs*4, (char *) dummyname + CALL_DUMMY_START_OFFSET + 8); }
/* Push an empty stack frame, to record the current PC, etc. */
#define PUSH_DUMMY_FRAME { m68k_push_dummy_frame (); }
+extern void m68k_push_dummy_frame PARAMS ((void));
+
+extern void m68k_pop_frame PARAMS ((void));
+
/* Discard from the stack the innermost frame, restoring all registers. */
-#define POP_FRAME { m68k_pop_frame (); }
+#define POP_FRAME { m68k_pop_frame (); }
+
+/* Offset from SP to first arg on stack at first instruction of a function */
-/* Note that stuff for calling inferior functions is not in this file
- because the call dummy is different for different breakpoint
- instructions, which are different on different systems. Perhaps
- they could be merged, but I haven't bothered. */
+#define SP_ARG0 (1 * 4)