X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Flynx-nat.c;h=9f99b47d4b81fb05bbe89985a46980be8a5f9cdd;hb=9cbc6ef04e5d04231f2ac1c4b7fd9848d9a2b3b0;hp=20a7e163ee82e912c7179c1ed7231b4f7993b80a;hpb=fba45db2faf619e71856ee38ec63949c0ef6903e;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/lynx-nat.c b/gdb/lynx-nat.c index 20a7e163ee..9f99b47d4b 100644 --- a/gdb/lynx-nat.c +++ b/gdb/lynx-nat.c @@ -1,5 +1,7 @@ /* Native-dependent code for LynxOS. - Copyright 1993, 1994 Free Software Foundation, Inc. + + Copyright 1993, 1994, 1995, 1996, 1999, 2000, 2001, 2003 Free + Software Foundation, Inc. This file is part of GDB. @@ -23,9 +25,10 @@ #include "inferior.h" #include "target.h" #include "gdbcore.h" +#include "regcache.h" #include -#include +#Include "gdb_wait.h" #include static unsigned long registers_addr (int pid); @@ -253,214 +256,6 @@ static int regmap[] = #endif /* rs6000 */ -#ifdef SPARC - -/* This routine handles some oddball cases for Sparc registers and LynxOS. - In partucular, it causes refs to G0, g5->7, and all fp regs to return zero. - It also handles knows where to find the I & L regs on the stack. */ - -void -fetch_inferior_registers (int regno) -{ - int whatregs = 0; - -#define WHATREGS_FLOAT 1 -#define WHATREGS_GEN 2 -#define WHATREGS_STACK 4 - - if (regno == -1) - whatregs = WHATREGS_FLOAT | WHATREGS_GEN | WHATREGS_STACK; - else if (regno >= L0_REGNUM && regno <= I7_REGNUM) - whatregs = WHATREGS_STACK; - else if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32) - whatregs = WHATREGS_FLOAT; - else - whatregs = WHATREGS_GEN; - - if (whatregs & WHATREGS_GEN) - { - struct econtext ec; /* general regs */ - char buf[MAX_REGISTER_RAW_SIZE]; - int retval; - int i; - - errno = 0; - retval = ptrace (PTRACE_GETREGS, inferior_pid, (PTRACE_ARG3_TYPE) & ec, - 0); - if (errno) - perror_with_name ("ptrace(PTRACE_GETREGS)"); - - memset (buf, 0, REGISTER_RAW_SIZE (G0_REGNUM)); - supply_register (G0_REGNUM, buf); - supply_register (TBR_REGNUM, (char *) &ec.tbr); - - memcpy (®isters[REGISTER_BYTE (G1_REGNUM)], &ec.g1, - 4 * REGISTER_RAW_SIZE (G1_REGNUM)); - for (i = G1_REGNUM; i <= G1_REGNUM + 3; i++) - register_valid[i] = 1; - - supply_register (PS_REGNUM, (char *) &ec.psr); - supply_register (Y_REGNUM, (char *) &ec.y); - supply_register (PC_REGNUM, (char *) &ec.pc); - supply_register (NPC_REGNUM, (char *) &ec.npc); - supply_register (WIM_REGNUM, (char *) &ec.wim); - - memcpy (®isters[REGISTER_BYTE (O0_REGNUM)], ec.o, - 8 * REGISTER_RAW_SIZE (O0_REGNUM)); - for (i = O0_REGNUM; i <= O0_REGNUM + 7; i++) - register_valid[i] = 1; - } - - if (whatregs & WHATREGS_STACK) - { - CORE_ADDR sp; - int i; - - sp = read_register (SP_REGNUM); - - target_read_memory (sp + FRAME_SAVED_I0, - ®isters[REGISTER_BYTE (I0_REGNUM)], - 8 * REGISTER_RAW_SIZE (I0_REGNUM)); - for (i = I0_REGNUM; i <= I7_REGNUM; i++) - register_valid[i] = 1; - - target_read_memory (sp + FRAME_SAVED_L0, - ®isters[REGISTER_BYTE (L0_REGNUM)], - 8 * REGISTER_RAW_SIZE (L0_REGNUM)); - for (i = L0_REGNUM; i <= L0_REGNUM + 7; i++) - register_valid[i] = 1; - } - - if (whatregs & WHATREGS_FLOAT) - { - struct fcontext fc; /* fp regs */ - int retval; - int i; - - errno = 0; - retval = ptrace (PTRACE_GETFPREGS, inferior_pid, (PTRACE_ARG3_TYPE) & fc, - 0); - if (errno) - perror_with_name ("ptrace(PTRACE_GETFPREGS)"); - - memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], fc.f.fregs, - 32 * REGISTER_RAW_SIZE (FP0_REGNUM)); - for (i = FP0_REGNUM; i <= FP0_REGNUM + 31; i++) - register_valid[i] = 1; - - supply_register (FPS_REGNUM, (char *) &fc.fsr); - } -} - -/* This routine handles storing of the I & L regs for the Sparc. The trick - here is that they actually live on the stack. The really tricky part is - that when changing the stack pointer, the I & L regs must be written to - where the new SP points, otherwise the regs will be incorrect when the - process is started up again. We assume that the I & L regs are valid at - this point. */ - -void -store_inferior_registers (int regno) -{ - int whatregs = 0; - - if (regno == -1) - whatregs = WHATREGS_FLOAT | WHATREGS_GEN | WHATREGS_STACK; - else if (regno >= L0_REGNUM && regno <= I7_REGNUM) - whatregs = WHATREGS_STACK; - else if (regno >= FP0_REGNUM && regno < FP0_REGNUM + 32) - whatregs = WHATREGS_FLOAT; - else if (regno == SP_REGNUM) - whatregs = WHATREGS_STACK | WHATREGS_GEN; - else - whatregs = WHATREGS_GEN; - - if (whatregs & WHATREGS_GEN) - { - struct econtext ec; /* general regs */ - int retval; - - ec.tbr = read_register (TBR_REGNUM); - memcpy (&ec.g1, ®isters[REGISTER_BYTE (G1_REGNUM)], - 4 * REGISTER_RAW_SIZE (G1_REGNUM)); - - ec.psr = read_register (PS_REGNUM); - ec.y = read_register (Y_REGNUM); - ec.pc = read_register (PC_REGNUM); - ec.npc = read_register (NPC_REGNUM); - ec.wim = read_register (WIM_REGNUM); - - memcpy (ec.o, ®isters[REGISTER_BYTE (O0_REGNUM)], - 8 * REGISTER_RAW_SIZE (O0_REGNUM)); - - errno = 0; - retval = ptrace (PTRACE_SETREGS, inferior_pid, (PTRACE_ARG3_TYPE) & ec, - 0); - if (errno) - perror_with_name ("ptrace(PTRACE_SETREGS)"); - } - - if (whatregs & WHATREGS_STACK) - { - int regoffset; - CORE_ADDR sp; - - sp = read_register (SP_REGNUM); - - if (regno == -1 || regno == SP_REGNUM) - { - if (!register_valid[L0_REGNUM + 5]) - abort (); - target_write_memory (sp + FRAME_SAVED_I0, - ®isters[REGISTER_BYTE (I0_REGNUM)], - 8 * REGISTER_RAW_SIZE (I0_REGNUM)); - - target_write_memory (sp + FRAME_SAVED_L0, - ®isters[REGISTER_BYTE (L0_REGNUM)], - 8 * REGISTER_RAW_SIZE (L0_REGNUM)); - } - else if (regno >= L0_REGNUM && regno <= I7_REGNUM) - { - if (!register_valid[regno]) - abort (); - if (regno >= L0_REGNUM && regno <= L0_REGNUM + 7) - regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM) - + FRAME_SAVED_L0; - else - regoffset = REGISTER_BYTE (regno) - REGISTER_BYTE (I0_REGNUM) - + FRAME_SAVED_I0; - target_write_memory (sp + regoffset, - ®isters[REGISTER_BYTE (regno)], - REGISTER_RAW_SIZE (regno)); - } - } - - if (whatregs & WHATREGS_FLOAT) - { - struct fcontext fc; /* fp regs */ - int retval; - -/* We read fcontext first so that we can get good values for fq_t... */ - errno = 0; - retval = ptrace (PTRACE_GETFPREGS, inferior_pid, (PTRACE_ARG3_TYPE) & fc, - 0); - if (errno) - perror_with_name ("ptrace(PTRACE_GETFPREGS)"); - - memcpy (fc.f.fregs, ®isters[REGISTER_BYTE (FP0_REGNUM)], - 32 * REGISTER_RAW_SIZE (FP0_REGNUM)); - - fc.fsr = read_register (FPS_REGNUM); - - errno = 0; - retval = ptrace (PTRACE_SETFPREGS, inferior_pid, (PTRACE_ARG3_TYPE) & fc, - 0); - if (errno) - perror_with_name ("ptrace(PTRACE_SETFPREGS)"); - } -} -#endif /* SPARC */ - #if defined (I386) || defined (M68K) || defined (rs6000) /* Return the offset relative to the start of the per-thread data to the @@ -506,42 +301,39 @@ fetch_inferior_registers (int regno) else reglo = reghi = regno; - ecp = registers_addr (inferior_pid); - - for (regno = reglo; regno <= reghi; regno++) - { - char buf[MAX_REGISTER_RAW_SIZE]; - int ptrace_fun = PTRACE_PEEKTHREAD; + ecp = registers_addr (PIDGET (inferior_ptid)); + { + char buf[MAX_REGISTER_SIZE]; + for (regno = reglo; regno <= reghi; regno++) + { + int ptrace_fun = PTRACE_PEEKTHREAD; + #ifdef M68K - ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD; + ptrace_fun = regno == SP_REGNUM ? PTRACE_PEEKUSP : PTRACE_PEEKTHREAD; #endif - - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) - { - unsigned int reg; - - errno = 0; - reg = ptrace (ptrace_fun, inferior_pid, - (PTRACE_ARG3_TYPE) (ecp + regmap[regno] + i), 0); - if (errno) - perror_with_name ("ptrace(PTRACE_PEEKUSP)"); - - *(int *) &buf[i] = reg; - } - supply_register (regno, buf); - } + + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) + { + unsigned int reg; + + errno = 0; + reg = ptrace (ptrace_fun, PIDGET (inferior_ptid), + (PTRACE_ARG3_TYPE) (ecp + regmap[regno] + i), 0); + if (errno) + perror_with_name ("ptrace(PTRACE_PEEKUSP)"); + + *(int *) &buf[i] = reg; + } + supply_register (regno, buf); + } + } } /* Store our register values back into the inferior. If REGNO is -1, do this for all registers. Otherwise, REGNO specifies which register (so we can save time). */ -/* Registers we shouldn't try to store. */ -#if !defined (CANNOT_STORE_REGISTER) -#define CANNOT_STORE_REGISTER(regno) 0 -#endif - void store_inferior_registers (int regno) { @@ -557,7 +349,7 @@ store_inferior_registers (int regno) else reglo = reghi = regno; - ecp = registers_addr (inferior_pid); + ecp = registers_addr (PIDGET (inferior_ptid)); for (regno = reglo; regno <= reghi; regno++) { @@ -570,14 +362,14 @@ store_inferior_registers (int regno) ptrace_fun = regno == SP_REGNUM ? PTRACE_POKEUSP : PTRACE_POKEUSER; #endif - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i += sizeof (int)) { unsigned int reg; - reg = *(unsigned int *) ®isters[REGISTER_BYTE (regno) + i]; + reg = *(unsigned int *) &deprecated_registers[DEPRECATED_REGISTER_BYTE (regno) + i]; errno = 0; - ptrace (ptrace_fun, inferior_pid, + ptrace (ptrace_fun, PIDGET (inferior_ptid), (PTRACE_ARG3_TYPE) (ecp + regmap[regno] + i), reg); if (errno) perror_with_name ("ptrace(PTRACE_POKEUSP)"); @@ -589,12 +381,13 @@ store_inferior_registers (int regno) /* Wait for child to do something. Return pid of child, or -1 in case of error; store status through argument pointer OURSTATUS. */ -int -child_wait (int pid, struct target_waitstatus *ourstatus) +ptid_t +child_wait (ptid_t ptid, struct target_waitstatus *ourstatus) { int save_errno; int thread; union wait status; + int pid; while (1) { @@ -620,7 +413,7 @@ child_wait (int pid, struct target_waitstatus *ourstatus) return -1; } - if (pid != PIDGET (inferior_pid)) /* Some other process?!? */ + if (pid != PIDGET (inferior_ptid)) /* Some other process?!? */ continue; thread = status.w_tid; /* Get thread id from status */ @@ -628,26 +421,27 @@ child_wait (int pid, struct target_waitstatus *ourstatus) /* Initial thread value can only be acquired via wait, so we have to resort to this hack. */ - if (TIDGET (inferior_pid) == 0 && thread != 0) + if (TIDGET (inferior_ptid) == 0 && thread != 0) { - inferior_pid = BUILDPID (inferior_pid, thread); - add_thread (inferior_pid); + inferior_ptid = MERGEPID (PIDGET (inferior_ptid), thread); + add_thread (inferior_ptid); } - pid = BUILDPID (pid, thread); + ptid = BUILDPID (pid, thread); /* We've become a single threaded process again. */ if (thread == 0) - inferior_pid = pid; + inferior_ptid = ptid; /* Check for thread creation. */ if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP - && !in_thread_list (pid)) + && !in_thread_list (ptid)) { int realsig; - realsig = ptrace (PTRACE_GETTRACESIG, pid, (PTRACE_ARG3_TYPE) 0, 0); + realsig = ptrace (PTRACE_GETTRACESIG, PIDGET (ptid), + (PTRACE_ARG3_TYPE) 0, 0); if (realsig == SIGNEWTHREAD) { @@ -655,7 +449,7 @@ child_wait (int pid, struct target_waitstatus *ourstatus) realsig -- the code in wait_for_inferior expects SIGTRAP. */ ourstatus->kind = TARGET_WAITKIND_SPURIOUS; ourstatus->value.sig = TARGET_SIGNAL_0; - return pid; + return ptid; } else error ("Signal for unknown thread was not SIGNEWTHREAD"); @@ -664,15 +458,16 @@ child_wait (int pid, struct target_waitstatus *ourstatus) /* Check for thread termination. */ else if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP - && in_thread_list (pid)) + && in_thread_list (ptid)) { int realsig; - realsig = ptrace (PTRACE_GETTRACESIG, pid, (PTRACE_ARG3_TYPE) 0, 0); + realsig = ptrace (PTRACE_GETTRACESIG, PIDGET (ptid), + (PTRACE_ARG3_TYPE) 0, 0); if (realsig == SIGTHREADEXIT) { - ptrace (PTRACE_CONT, PIDGET (pid), (PTRACE_ARG3_TYPE) 0, 0); + ptrace (PTRACE_CONT, PIDGET (ptid), (PTRACE_ARG3_TYPE) 0, 0); continue; } } @@ -703,14 +498,16 @@ child_wait (int pid, struct target_waitstatus *ourstatus) store_waitstatus (ourstatus, status.w_status); #endif - return pid; + return ptid; } } /* Return nonzero if the given thread is still alive. */ int -child_thread_alive (int pid) +child_thread_alive (ptid_t ptid) { + int pid = PIDGET (ptid); + /* Arggh. Apparently pthread_kill only works for threads within the process that calls pthread_kill. @@ -728,9 +525,10 @@ child_thread_alive (int pid) If SIGNAL is nonzero, give it that signal. */ void -child_resume (int pid, int step, enum target_signal signal) +child_resume (ptid_t ptid, int step, enum target_signal signal) { int func; + int pid = PIDGET (ptid); errno = 0; @@ -738,7 +536,7 @@ child_resume (int pid, int step, enum target_signal signal) we only want to step/continue a single thread. */ if (pid == -1) { - pid = inferior_pid; + pid = PIDGET (inferior_ptid); func = step ? PTRACE_SINGLESTEP : PTRACE_CONT; } else @@ -764,11 +562,11 @@ child_resume (int pid, int step, enum target_signal signal) buffer. */ char * -child_pid_to_str (int pid) +child_pid_to_str (ptid_t ptid) { static char buf[40]; - sprintf (buf, "process %d thread %d", PIDGET (pid), TIDGET (pid)); + sprintf (buf, "process %d thread %d", PIDGET (ptid), TIDGET (ptid)); return buf; } @@ -822,5 +620,5 @@ static struct core_fns lynx_core_fns = void _initialize_core_lynx (void) { - add_core_fns (&lynx_core_fns); + deprecated_add_core_fns (&lynx_core_fns); }