This is tm.h in view mode; [Download] [Up]
/* Parameters for execution on a Sun, for GDB, the GNU debugger.
Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
This file is part of GDB.
GDB 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 1, or (at your option)
any later version.
GDB 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 GDB; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <mach/mach.h>
#include <stdio.h>
#define HAVE_68881
#include "tm-68k.h"
/* Define this if the C compiler puts an underscore at the front
of external names before giving them to the linker. */
#define NAMES_HAVE_UNDERSCORE
/* Debugger information will be in DBX format. */
#define READ_DBX_FORMAT
/* Address of the end of stack space. We get this from the system
include files. */
#include <sys/types.h>
#include <machine/vmparam.h>
#define STACK_END_ADDR USRSTACK
/* Things needed for making the inferior call functions. */
/* Push an empty stack frame, to record the current PC, etc. */
#if 1
#define PUSH_DUMMY_FRAME { pushDummyFrame(); }
#else /* 1 */
#define 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); \
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); } \
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); }
#endif /* 1 */
/* Discard from the stack the innermost frame,
restoring all saved registers. */
#define POP_FRAME \
{ register struct frame_info *frame = get_current_frame (); \
register CORE_ADDR fp; \
register int regnum; \
struct frame_saved_regs fsr; \
char raw_buffer[12]; \
\
fp = FRAME_FP(frame); \
get_frame_saved_regs (frame, &fsr); \
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); }\
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 (); }
/* This sequence of words is the instructions
fmovem 0xff,-(sp)
moveml 0xfffc,-(sp)
clrw -(sp)
movew ccr,-(sp)
/..* 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
trap #15
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, 0x4e4f4e71}
#define CALL_DUMMY_LENGTH 28
#define CALL_DUMMY_START_OFFSET 12
/* Insert the specified number of args and function address
into a call sequence of the above form stored at DUMMYNAME. */
#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
{ *(int *)((char *) dummyname + 20) = nargs * 4; \
*(int *)((char *) dummyname + 14) = fun; }
#define ATTACH_DETACH
/*
* Request values for the ptrace system call
*/
enum ptracereq {
PTRACE_TRACEME = 0, /* 0, by tracee to begin tracing */
PTRACE_CHILDDONE = 0, /* 0, tracee is done with his half */
PTRACE_PEEKTEXT, /* 1, read word from text segment */
PTRACE_PEEKDATA, /* 2, read word from data segment */
PTRACE_PEEKUSER, /* 3, read word from user struct */
PTRACE_POKETEXT, /* 4, write word into text segment */
PTRACE_POKEDATA, /* 5, write word into data segment */
PTRACE_POKEUSER, /* 6, write word into user struct */
PTRACE_CONT, /* 7, continue process */
PTRACE_KILL, /* 8, terminate process */
PTRACE_SINGLESTEP, /* 9, single step process */
PTRACE_ATTACH, /* 10, attach to an existing process */
PTRACE_DETACH, /* 11, detach from a process */
PTRACE_GETREGS, /* 12, get all registers */
PTRACE_SETREGS, /* 13, set all registers */
PTRACE_GETFPREGS, /* 14, get all floating point regs */
PTRACE_SETFPREGS, /* 15, set all floating point regs */
PTRACE_READDATA, /* 16, read data segment */
PTRACE_WRITEDATA, /* 17, write data segment */
PTRACE_READTEXT, /* 18, read text segment */
PTRACE_WRITETEXT, /* 19, write text segment */
PTRACE_GETFPAREGS, /* 20, get all fpa regs */
PTRACE_SETFPAREGS, /* 21, set all fpa regs */
};
/* I have no idea what this shit is for */
#define B19200 14
#define B38400 15
#ifdef FRAME_CHAIN
#undef FRAME_CHAIN
#endif FRAME_CHAIN
//#define FRAME_CHAIN(thisframe) \
// (((thisframe)->pc) ? read_memory_integer ((thisframe)->frame, 4) : 0)
#define FRAME_CHAIN(thisframe) \
read_memory_integer ((thisframe)->frame, 4)
#ifdef FRAME_CHAIN_VALID
#undef FRAME_CHAIN_VALID
#endif FRAME_CHAIN_VALID
//#define FRAME_CHAIN_VALID(chain, thisframe) \
// (chain != 0 && (FRAME_SAVED_PC (thisframe)))
#define FRAME_CHAIN_VALID(chain, thisframe) (chain)
#ifdef SKIP_PROLOGUE
#undef SKIP_PROLOGUE
#endif SKIP_PROLOGUE
#define SKIP_PROLOGUE(pc) (pc = skip_prologue(pc))
#define MARK_PROLOGUE(f, s, e) mark_prologue(f, s, e)
#define KERNEL_BREAKPOINT {0x4e, 0x4e}
#define INITIAL_RET_PC() read_memory_integer(read_register(SP_REGNUM), 4)
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.