X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Finfptrace.c;h=011224e4ae980174411619564c76e0e7d266468f;hb=2fe3b329f69ca294a8ad3f1f655df7db33a6eb65;hp=e9fa66d855529caecb60ee3b3359708e7418d627;hpb=51b57ded888cbdacb5ad126363f8ae6adc9541b6;p=binutils-gdb.git diff --git a/gdb/infptrace.c b/gdb/infptrace.c index e9fa66d8555..011224e4ae9 100644 --- a/gdb/infptrace.c +++ b/gdb/infptrace.c @@ -30,12 +30,20 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include -#ifndef USG + +#ifndef NO_PTRACE_H +#ifdef PTRACE_IN_WRONG_PLACE +#include +#else #include #endif +#endif /* NO_PTRACE_H */ #if !defined (PT_KILL) #define PT_KILL 8 +#endif + +#if !defined (PT_STEP) #define PT_STEP 9 #define PT_CONTINUE 7 #define PT_READ_U 3 @@ -44,7 +52,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #define PT_READ_D 2 #define PT_WRITE_I 4 #define PT_WRITE_D 5 -#endif /* No PT_KILL. */ +#endif /* No PT_STEP. */ #ifndef PT_ATTACH #define PT_ATTACH PTRACE_ATTACH @@ -57,7 +65,12 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef NO_SYS_FILE #include #endif +#if 0 +/* Don't think this is used anymore. On the sequent (not sure whether it's + dynix or ptx or both), it is included unconditionally by sys/user.h and + not protected against multiple inclusion. */ #include +#endif #if !defined (FETCH_INFERIOR_REGISTERS) #include /* Probably need to poke the user structure */ @@ -76,30 +89,31 @@ call_ptrace (request, pid, addr, data) PTRACE_ARG3_TYPE addr; int data; { - return ptrace (request, pid, addr, data); + return ptrace (request, pid, addr, data +#if defined (FIVE_ARG_PTRACE) + /* Deal with HPUX 8.0 braindamage. We never use the + calls which require the fifth argument. */ + , 0 +#endif + ); } -#ifdef DEBUG_PTRACE +#if defined (DEBUG_PTRACE) || defined (FIVE_ARG_PTRACE) /* For the rest of the file, use an extra level of indirection */ /* This lets us breakpoint usefully on call_ptrace. */ #define ptrace call_ptrace #endif -/* This is used when GDB is exiting. It gives less chance of error.*/ - void -kill_inferior_fast () +kill_inferior () { if (inferior_pid == 0) return; + /* ptrace PT_KILL only works if process is stopped!!! So stop it with + a real signal first, if we can. */ + kill (inferior_pid, SIGKILL); ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0); wait ((int *)0); -} - -void -kill_inferior () -{ - kill_inferior_fast (); target_mourn_inferior (); } @@ -108,38 +122,46 @@ kill_inferior () If SIGNAL is nonzero, give it that signal. */ void -child_resume (step, signal) +child_resume (pid, step, signal) + int pid; int step; - int signal; + enum target_signal signal; { errno = 0; + if (pid == -1) + /* Resume all threads. */ +#ifdef PIDGET + /* This is for Lynx, and should be cleaned up by having Lynx be + a separate debugging target, with its own target_resume function. */ + pid = PIDGET (inferior_pid); +#else + /* I think this only gets used in the non-threaded case, where "resume + all threads" and "resume inferior_pid" are the same. */ + pid = inferior_pid; +#endif + /* An address of (PTRACE_ARG3_TYPE)1 tells ptrace to continue from where it was. (If GDB wanted it to start some other way, we have already - written a new PC value to the child.) */ + written a new PC value to the child.) + + If this system does not support PT_STEP, a higher level function will + have called single_step() to transmute the step request into a + continue request (by setting breakpoints on all possible successor + instructions), so we don't have to worry about that here. */ if (step) -#ifdef NO_SINGLE_STEP - single_step (signal); -#else - ptrace (PT_STEP, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal); -#endif + ptrace (PT_STEP, pid, (PTRACE_ARG3_TYPE) 1, + target_signal_to_host (signal)); else -#ifdef AIX_BUGGY_PTRACE_CONTINUE - AIX_BUGGY_PTRACE_CONTINUE; -#else - ptrace (PT_CONTINUE, inferior_pid, (PTRACE_ARG3_TYPE) 1, signal); -#endif + ptrace (PT_CONTINUE, pid, (PTRACE_ARG3_TYPE) 1, + target_signal_to_host (signal)); if (errno) perror_with_name ("ptrace"); } #ifdef ATTACH_DETACH -/* Nonzero if we are debugging an attached process rather than - an inferior. */ -extern int attach_flag; - /* Start debugging the process whose number is PID. */ int attach (pid) @@ -169,17 +191,22 @@ detach (signal) } #endif /* ATTACH_DETACH */ -#if !defined (FETCH_INFERIOR_REGISTERS) +/* Default the type of the ptrace transfer to int. */ +#ifndef PTRACE_XFER_TYPE +#define PTRACE_XFER_TYPE int +#endif /* KERNEL_U_ADDR is the amount to subtract from u.u_ar0 to get the offset in the core file of the register values. */ -#if defined (KERNEL_U_ADDR_BSD) +#if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS) /* Get kernel_u_addr using BSD-style nlist(). */ CORE_ADDR kernel_u_addr; +#endif /* KERNEL_U_ADDR_BSD. */ void _initialize_kernel_u_addr () { +#if defined (KERNEL_U_ADDR_BSD) && !defined (FETCH_INFERIOR_REGISTERS) struct nlist names[2]; names[0].n_un.n_name = "_u"; @@ -188,30 +215,10 @@ _initialize_kernel_u_addr () kernel_u_addr = names[0].n_value; else fatal ("Unable to get kernel u area address."); -} #endif /* KERNEL_U_ADDR_BSD. */ - -#if defined (KERNEL_U_ADDR_HPUX) -/* Get kernel_u_addr using HPUX-style nlist(). */ -CORE_ADDR kernel_u_addr; - -struct hpnlist { - char * n_name; - long n_value; - unsigned char n_type; - unsigned char n_length; - short n_almod; - short n_unused; -}; -static struct hpnlist nl[] = {{ "_u", -1, }, { (char *) 0, }}; - -/* read the value of the u area from the hp-ux kernel */ -void _initialize_kernel_u_addr () -{ - nlist ("/hp-ux", &nl); - kernel_u_addr = nl[0].n_value; } -#endif /* KERNEL_U_ADDR_HPUX. */ + +#if !defined (FETCH_INFERIOR_REGISTERS) #if !defined (offsetof) #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER) @@ -246,7 +253,7 @@ fetch_register (regno) if (CANNOT_FETCH_REGISTER (regno)) { - bzero (buf, REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ + memset (buf, '\0', REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ supply_register (regno, buf); return; } @@ -254,12 +261,12 @@ fetch_register (regno) offset = U_REGS_OFFSET; regaddr = register_addr (regno, offset); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) { errno = 0; - *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid, - (PTRACE_ARG3_TYPE) regaddr, 0); - regaddr += sizeof (int); + *(PTRACE_XFER_TYPE *) &buf[i] = ptrace (PT_READ_U, inferior_pid, + (PTRACE_ARG3_TYPE) regaddr, 0); + regaddr += sizeof (PTRACE_XFER_TYPE); if (errno != 0) { sprintf (mess, "reading register %s (#%d)", reg_names[regno], regno); @@ -298,7 +305,6 @@ store_inferior_registers (regno) { register unsigned int regaddr; char buf[80]; - extern char registers[]; register int i; unsigned int offset = U_REGS_OFFSET; @@ -306,17 +312,17 @@ store_inferior_registers (regno) if (regno >= 0) { regaddr = register_addr (regno, offset); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int)) + for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(PTRACE_XFER_TYPE)) { errno = 0; ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, - *(int *) ®isters[REGISTER_BYTE (regno) + i]); + *(PTRACE_XFER_TYPE *) ®isters[REGISTER_BYTE (regno) + i]); if (errno != 0) { sprintf (buf, "writing register number %d(%d)", regno, i); perror_with_name (buf); } - regaddr += sizeof(int); + regaddr += sizeof(PTRACE_XFER_TYPE); } } else @@ -326,23 +332,25 @@ store_inferior_registers (regno) if (CANNOT_STORE_REGISTER (regno)) continue; regaddr = register_addr (regno, offset); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(int)) + for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof(PTRACE_XFER_TYPE)) { errno = 0; ptrace (PT_WRITE_U, inferior_pid, (PTRACE_ARG3_TYPE) regaddr, - *(int *) ®isters[REGISTER_BYTE (regno) + i]); + *(PTRACE_XFER_TYPE *) ®isters[REGISTER_BYTE (regno) + i]); if (errno != 0) { sprintf (buf, "writing register number %d(%d)", regno, i); perror_with_name (buf); } - regaddr += sizeof(int); + regaddr += sizeof(PTRACE_XFER_TYPE); } } } } #endif /* !defined (FETCH_INFERIOR_REGISTERS). */ + +#if !defined (CHILD_XFER_MEMORY) /* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory in the NEW_SUN_PTRACE case. It ought to be straightforward. But it appears that writing did @@ -368,18 +376,20 @@ child_xfer_memory (memaddr, myaddr, len, write, target) { register int i; /* Round starting address down to longword boundary. */ - register CORE_ADDR addr = memaddr & - sizeof (int); + register CORE_ADDR addr = memaddr & - sizeof (PTRACE_XFER_TYPE); /* Round ending address up; get number of longwords that makes. */ register int count - = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int); + = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) + / sizeof (PTRACE_XFER_TYPE); /* Allocate buffer of that many longwords. */ - register int *buffer = (int *) alloca (count * sizeof (int)); + register PTRACE_XFER_TYPE *buffer + = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE)); if (write) { /* Fill start and end extra bytes of buffer with existing memory data. */ - if (addr != memaddr || len < (int)sizeof (int)) { + if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE)) { /* Need part of initial word -- fetch it. */ buffer[0] = ptrace (PT_READ_I, inferior_pid, (PTRACE_ARG3_TYPE) addr, 0); @@ -389,18 +399,20 @@ child_xfer_memory (memaddr, myaddr, len, write, target) { buffer[count - 1] = ptrace (PT_READ_I, inferior_pid, - (PTRACE_ARG3_TYPE) (addr + (count - 1) * sizeof (int)), + ((PTRACE_ARG3_TYPE) + (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))), 0); } /* Copy data to be written over corresponding part of buffer */ - (void) memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, - len); + memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), + myaddr, + len); /* Write the entire buffer. */ - for (i = 0; i < count; i++, addr += sizeof (int)) + for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) { errno = 0; ptrace (PT_WRITE_D, inferior_pid, (PTRACE_ARG3_TYPE) addr, @@ -420,7 +432,7 @@ child_xfer_memory (memaddr, myaddr, len, write, target) else { /* Read all the longwords */ - for (i = 0; i < count; i++, addr += sizeof (int)) + for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) { errno = 0; buffer[i] = ptrace (PT_READ_I, inferior_pid, @@ -431,8 +443,10 @@ child_xfer_memory (memaddr, myaddr, len, write, target) } /* Copy appropriate bytes out of the buffer. */ - (void) memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), - len); + memcpy (myaddr, + (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), + len); } return len; } +#endif /* !defined (CHILD_XFER_MEMORY). */