X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fi386-linux-nat.c;h=631e4e774ee40c4c3ecb6df76b1752dc05c74856;hb=23a6d36940157c674aedaf5a9d4b38676ea0d9e9;hp=49149830e8495b56b01ac77a43d397699e874bf2;hpb=756ed20662a5a24a1e20d6b73ecd7aa5527ecdb9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i386-linux-nat.c b/gdb/i386-linux-nat.c index 49149830e8..631e4e774e 100644 --- a/gdb/i386-linux-nat.c +++ b/gdb/i386-linux-nat.c @@ -1,5 +1,6 @@ -/* Native-dependent code for Linux/x86. - Copyright 1999, 2000 Free Software Foundation, Inc. +/* Native-dependent code for GNU/Linux i386. + + Copyright 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GDB. @@ -21,12 +22,11 @@ #include "defs.h" #include "inferior.h" #include "gdbcore.h" +#include "regcache.h" +#include "linux-nat.h" -/* For i386_linux_skip_solib_resolver. */ -#include "symtab.h" -#include "symfile.h" -#include "objfiles.h" - +#include "gdb_assert.h" +#include "gdb_string.h" #include #include #include @@ -35,32 +35,53 @@ #include #endif +#ifndef ORIG_EAX +#define ORIG_EAX -1 +#endif + +#ifdef HAVE_SYS_DEBUGREG_H +#include +#endif + +#ifndef DR_FIRSTADDR +#define DR_FIRSTADDR 0 +#endif + +#ifndef DR_LASTADDR +#define DR_LASTADDR 3 +#endif + +#ifndef DR_STATUS +#define DR_STATUS 6 +#endif + +#ifndef DR_CONTROL +#define DR_CONTROL 7 +#endif + /* Prototypes for supply_gregset etc. */ #include "gregset.h" /* Prototypes for i387_supply_fsave etc. */ -#include "i387-nat.h" +#include "i387-tdep.h" -/* Prototypes for local functions. */ -static void dummy_sse_values (void); +/* Defines for XMM0_REGNUM etc. */ +#include "i386-tdep.h" -/* On Linux, threads are implemented as pseudo-processes, in which - case we may be tracing more than one process at a time. In that - case, inferior_pid will contain the main process ID and the - individual thread (process) ID mashed together. These macros are - used to separate them out. These definitions should be overridden - if thread support is included. */ +/* Defines I386_LINUX_ORIG_EAX_REGNUM. */ +#include "i386-linux-tdep.h" -#if !defined (PIDGET) /* Default definition for PIDGET/TIDGET. */ -#define PIDGET(PID) PID -#define TIDGET(PID) 0 -#endif +/* Defines ps_err_e, struct ps_prochandle. */ +#include "gdb_proc_service.h" + +/* Prototypes for local functions. */ +static void dummy_sse_values (void); -/* The register sets used in Linux ELF core-dumps are identical to the - register sets in `struct user' that is used for a.out core-dumps, - and is also used by `ptrace'. The corresponding types are - `elf_gregset_t' for the general-purpose registers (with +/* The register sets used in GNU/Linux ELF core-dumps are identical to + the register sets in `struct user' that is used for a.out + core-dumps, and is also used by `ptrace'. The corresponding types + are `elf_gregset_t' for the general-purpose registers (with `elf_greg_t' the type of a single GP register) and `elf_fpregset_t' for the floating-point registers. @@ -76,15 +97,26 @@ static int regmap[] = EAX, ECX, EDX, EBX, UESP, EBP, ESI, EDI, EIP, EFL, CS, SS, - DS, ES, FS, GS + DS, ES, FS, GS, + -1, -1, -1, -1, /* st0, st1, st2, st3 */ + -1, -1, -1, -1, /* st4, st5, st6, st7 */ + -1, -1, -1, -1, /* fctrl, fstat, ftag, fiseg */ + -1, -1, -1, -1, /* fioff, foseg, fooff, fop */ + -1, -1, -1, -1, /* xmm0, xmm1, xmm2, xmm3 */ + -1, -1, -1, -1, /* xmm4, xmm5, xmm6, xmm6 */ + -1, /* mxcsr */ + ORIG_EAX }; /* Which ptrace request retrieves which registers? These apply to the corresponding SET requests as well. */ + #define GETREGS_SUPPLIES(regno) \ - (0 <= (regno) && (regno) <= 15) + ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM) + #define GETFPREGS_SUPPLIES(regno) \ (FP0_REGNUM <= (regno) && (regno) <= LAST_FPU_CTRL_REGNUM) + #define GETFPXREGS_SUPPLIES(regno) \ (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM) @@ -114,166 +146,87 @@ int have_ptrace_getfpxregs = ; -/* Fetching registers directly from the U area, one at a time. */ +/* Support for the user struct. */ -/* FIXME: kettenis/2000-03-05: This duplicates code from `inptrace.c'. - The problem is that we define FETCH_INFERIOR_REGISTERS since we - want to use our own versions of {fetch,store}_inferior_registers - that use the GETREGS request. This means that the code in - `infptrace.c' is #ifdef'd out. But we need to fall back on that - code when GDB is running on top of a kernel that doesn't support - the GETREGS request. I want to avoid changing `infptrace.c' right - now. */ +/* Return the address of register REGNUM. BLOCKEND is the value of + u.u_ar0, which should point to the registers. */ -#ifndef PT_READ_U -#define PT_READ_U PTRACE_PEEKUSR -#endif -#ifndef PT_WRITE_U -#define PT_WRITE_U PTRACE_POKEUSR -#endif +CORE_ADDR +register_u_addr (CORE_ADDR blockend, int regnum) +{ + return (blockend + 4 * regmap[regnum]); +} -/* Default the type of the ptrace transfer to int. */ -#ifndef PTRACE_XFER_TYPE -#define PTRACE_XFER_TYPE int -#endif +/* Return the size of the user struct. */ -/* Registers we shouldn't try to fetch. */ -#if !defined (CANNOT_FETCH_REGISTER) -#define CANNOT_FETCH_REGISTER(regno) 0 -#endif +int +kernel_u_size (void) +{ + return (sizeof (struct user)); +} + + +/* Accessing registers through the U area, one at a time. */ /* Fetch one register. */ static void fetch_register (int regno) { - /* This isn't really an address. But ptrace thinks of it as one. */ - CORE_ADDR regaddr; - char mess[128]; /* For messages */ - register int i; - unsigned int offset; /* Offset of registers within the u area. */ - char buf[MAX_REGISTER_RAW_SIZE]; int tid; + int val; - if (CANNOT_FETCH_REGISTER (regno)) + gdb_assert (!have_ptrace_getregs); + if (cannot_fetch_register (regno)) { - memset (buf, '\0', REGISTER_RAW_SIZE (regno)); /* Supply zeroes */ - supply_register (regno, buf); + regcache_raw_supply (current_regcache, regno, NULL); return; } - /* Overload thread id onto process id */ - if ((tid = TIDGET (inferior_pid)) == 0) - tid = inferior_pid; /* no thread id, just use process id */ - - offset = U_REGS_OFFSET; - - regaddr = register_addr (regno, offset); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) - { - errno = 0; - *(PTRACE_XFER_TYPE *) & buf[i] = ptrace (PT_READ_U, tid, - (PTRACE_ARG3_TYPE) regaddr, 0); - regaddr += sizeof (PTRACE_XFER_TYPE); - if (errno != 0) - { - sprintf (mess, "reading register %s (#%d)", - REGISTER_NAME (regno), regno); - perror_with_name (mess); - } - } - supply_register (regno, buf); -} + /* GNU/Linux LWP ID's are process ID's. */ + tid = TIDGET (inferior_ptid); + if (tid == 0) + tid = PIDGET (inferior_ptid); /* Not a threaded program. */ -/* Fetch register values from the inferior. - If REGNO is negative, do this for all registers. - Otherwise, REGNO specifies which register (so we can save time). */ + errno = 0; + val = ptrace (PTRACE_PEEKUSER, tid, register_addr (regno, 0), 0); + if (errno != 0) + error ("Couldn't read register %s (#%d): %s.", REGISTER_NAME (regno), + regno, safe_strerror (errno)); -void -old_fetch_inferior_registers (int regno) -{ - if (regno >= 0) - { - fetch_register (regno); - } - else - { - for (regno = 0; regno < ARCH_NUM_REGS; regno++) - { - fetch_register (regno); - } - } + regcache_raw_supply (current_regcache, regno, &val); } -/* Registers we shouldn't try to store. */ -#if !defined (CANNOT_STORE_REGISTER) -#define CANNOT_STORE_REGISTER(regno) 0 -#endif - /* Store one register. */ static void store_register (int regno) { - /* This isn't really an address. But ptrace thinks of it as one. */ - CORE_ADDR regaddr; - char mess[128]; /* For messages */ - register int i; - unsigned int offset; /* Offset of registers within the u area. */ int tid; - - if (CANNOT_STORE_REGISTER (regno)) - { - return; - } - - /* Overload thread id onto process id */ - if ((tid = TIDGET (inferior_pid)) == 0) - tid = inferior_pid; /* no thread id, just use process id */ - - offset = U_REGS_OFFSET; - - regaddr = register_addr (regno, offset); - for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (PTRACE_XFER_TYPE)) - { - errno = 0; - ptrace (PT_WRITE_U, tid, (PTRACE_ARG3_TYPE) regaddr, - *(PTRACE_XFER_TYPE *) & registers[REGISTER_BYTE (regno) + i]); - regaddr += sizeof (PTRACE_XFER_TYPE); - if (errno != 0) - { - sprintf (mess, "writing register %s (#%d)", - REGISTER_NAME (regno), regno); - perror_with_name (mess); - } - } -} - -/* Store our register values back into the inferior. - If REGNO is negative, do this for all registers. - Otherwise, REGNO specifies which register (so we can save time). */ - -void -old_store_inferior_registers (int regno) -{ - if (regno >= 0) - { - store_register (regno); - } - else - { - for (regno = 0; regno < ARCH_NUM_REGS; regno++) - { - store_register (regno); - } - } + int val; + + gdb_assert (!have_ptrace_getregs); + if (cannot_store_register (regno)) + return; + + /* GNU/Linux LWP ID's are process ID's. */ + tid = TIDGET (inferior_ptid); + if (tid == 0) + tid = PIDGET (inferior_ptid); /* Not a threaded program. */ + + errno = 0; + regcache_collect (regno, &val); + ptrace (PTRACE_POKEUSER, tid, register_addr (regno, 0), val); + if (errno != 0) + error ("Couldn't write register %s (#%d): %s.", REGISTER_NAME (regno), + regno, safe_strerror (errno)); } /* Transfering the general-purpose registers between GDB, inferiors and core files. */ -/* Fill GDB's register array with the genereal-purpose register values +/* Fill GDB's register array with the general-purpose register values in *GREGSETP. */ void @@ -282,8 +235,12 @@ supply_gregset (elf_gregset_t *gregsetp) elf_greg_t *regp = (elf_greg_t *) gregsetp; int i; - for (i = 0; i < NUM_GREGS; i++) - supply_register (i, (char *) (regp + regmap[i])); + for (i = 0; i < I386_NUM_GREGS; i++) + regcache_raw_supply (current_regcache, i, regp + regmap[i]); + + if (I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS) + regcache_raw_supply (current_regcache, I386_LINUX_ORIG_EAX_REGNUM, + regp + ORIG_EAX); } /* Fill register REGNO (if it is a general-purpose register) in @@ -296,9 +253,13 @@ fill_gregset (elf_gregset_t *gregsetp, int regno) elf_greg_t *regp = (elf_greg_t *) gregsetp; int i; - for (i = 0; i < NUM_GREGS; i++) - if ((regno == -1 || regno == i)) - *(regp + regmap[i]) = *(elf_greg_t *) ®isters[REGISTER_BYTE (i)]; + for (i = 0; i < I386_NUM_GREGS; i++) + if (regno == -1 || regno == i) + regcache_collect (i, regp + regmap[i]); + + if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM) + && I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS) + regcache_collect (I386_LINUX_ORIG_EAX_REGNUM, regp + ORIG_EAX); } #ifdef HAVE_PTRACE_GETREGS @@ -360,7 +321,7 @@ static void store_regs (int tid, int regno) {} void supply_fpregset (elf_fpregset_t *fpregsetp) { - i387_supply_fsave ((char *) fpregsetp); + i387_supply_fsave (current_regcache, -1, fpregsetp); dummy_sse_values (); } @@ -422,17 +383,17 @@ static void store_fpregs (int tid, int regno) {} /* Fill GDB's register array with the floating-point and SSE register values in *FPXREGSETP. */ -static void +void supply_fpxregset (elf_fpxregset_t *fpxregsetp) { - i387_supply_fxsave ((char *) fpxregsetp); + i387_supply_fxsave (current_regcache, -1, fpxregsetp); } /* Fill register REGNO (if it is a floating-point or SSE register) in *FPXREGSETP with the value in GDB's register array. If REGNO is -1, do this for all registers. */ -static void +void fill_fpxregset (elf_fpxregset_t *fpxregsetp, int regno) { i387_fill_fxsave ((char *) fpxregsetp, regno); @@ -478,7 +439,15 @@ store_fpxregs (int tid, int regno) return 0; if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1) - perror_with_name ("Couldn't read floating-point and SSE registers"); + { + if (errno == EIO) + { + have_ptrace_getfpxregs = 0; + return 0; + } + + perror_with_name ("Couldn't read floating-point and SSE registers"); + } fill_fpxregset (&fpxregs, regno); @@ -496,15 +465,17 @@ store_fpxregs (int tid, int regno) static void dummy_sse_values (void) { + struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch); /* C doesn't have a syntax for NaN's, so write it out as an array of longs. */ static long dummy[4] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff }; static long mxcsr = 0x1f80; int reg; - for (reg = 0; reg < 8; reg++) - supply_register (XMM0_REGNUM + reg, (char *) dummy); - supply_register (MXCSR_REGNUM, (char *) &mxcsr); + for (reg = 0; reg < tdep->num_xmm_regs; reg++) + regcache_raw_supply (current_regcache, XMM0_REGNUM + reg, (char *) dummy); + if (tdep->num_xmm_regs > 0) + regcache_raw_supply (current_regcache, MXCSR_REGNUM, (char *) &mxcsr); } #else @@ -518,6 +489,25 @@ static void dummy_sse_values (void) {} /* Transferring arbitrary registers between GDB and inferior. */ +/* Check if register REGNO in the child process is accessible. + If we are accessing registers directly via the U area, only the + general-purpose registers are available. + All registers should be accessible if we have GETREGS support. */ + +int +cannot_fetch_register (int regno) +{ + gdb_assert (regno >= 0 && regno < NUM_REGS); + return (!have_ptrace_getregs && regmap[regno] == -1); +} + +int +cannot_store_register (int regno) +{ + gdb_assert (regno >= 0 && regno < NUM_REGS); + return (!have_ptrace_getregs && regmap[regno] == -1); +} + /* Fetch register REGNO from the child process. If REGNO is -1, do this for all registers (including the floating point and SSE registers). */ @@ -529,15 +519,21 @@ fetch_inferior_registers (int regno) /* Use the old method of peeking around in `struct user' if the GETREGS request isn't available. */ - if (! have_ptrace_getregs) + if (!have_ptrace_getregs) { - old_fetch_inferior_registers (regno); + int i; + + for (i = 0; i < NUM_REGS; i++) + if (regno == -1 || regno == i) + fetch_register (i); + return; } - /* Linux LWP ID's are process ID's. */ - if ((tid = TIDGET (inferior_pid)) == 0) - tid = inferior_pid; /* Not a threaded program. */ + /* GNU/Linux LWP ID's are process ID's. */ + tid = TIDGET (inferior_ptid); + if (tid == 0) + tid = PIDGET (inferior_ptid); /* Not a threaded program. */ /* Use the PTRACE_GETFPXREGS request whenever possible, since it transfers more registers in one system call, and we'll cache the @@ -548,9 +544,9 @@ fetch_inferior_registers (int regno) fetch_regs (tid); /* The call above might reset `have_ptrace_getregs'. */ - if (! have_ptrace_getregs) + if (!have_ptrace_getregs) { - old_fetch_inferior_registers (-1); + fetch_inferior_registers (regno); return; } @@ -581,7 +577,8 @@ fetch_inferior_registers (int regno) return; } - internal_error ("Got request for bad register number %d.", regno); + internal_error (__FILE__, __LINE__, + "Got request for bad register number %d.", regno); } /* Store register REGNO back into the child process. If REGNO is -1, @@ -594,15 +591,21 @@ store_inferior_registers (int regno) /* Use the old method of poking around in `struct user' if the SETREGS request isn't available. */ - if (! have_ptrace_getregs) + if (!have_ptrace_getregs) { - old_store_inferior_registers (regno); + int i; + + for (i = 0; i < NUM_REGS; i++) + if (regno == -1 || regno == i) + store_register (i); + return; } - /* Linux LWP ID's are process ID's. */ - if ((tid = TIDGET (inferior_pid)) == 0) - tid = inferior_pid; /* Not a threaded program. */ + /* GNU/Linux LWP ID's are process ID's. */ + tid = TIDGET (inferior_ptid); + if (tid == 0) + tid = PIDGET (inferior_ptid); /* Not a threaded program. */ /* Use the PTRACE_SETFPXREGS requests whenever possible, since it transfers more registers in one system call. But remember that @@ -634,85 +637,129 @@ store_inferior_registers (int regno) return; } - internal_error ("Got request to store bad register number %d.", regno); + internal_error (__FILE__, __LINE__, + "Got request to store bad register number %d.", regno); } -/* Interpreting register set info found in core files. */ +/* Support for debug registers. */ -/* Provide registers to GDB from a core file. +static unsigned long +i386_linux_dr_get (int regnum) +{ + int tid; + unsigned long value; + + /* FIXME: kettenis/2001-01-29: It's not clear what we should do with + multi-threaded processes here. For now, pretend there is just + one thread. */ + tid = PIDGET (inferior_ptid); + + /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the + ptrace call fails breaks debugging remote targets. The correct + way to fix this is to add the hardware breakpoint and watchpoint + stuff to the target vectore. For now, just return zero if the + ptrace call fails. */ + errno = 0; + value = ptrace (PTRACE_PEEKUSER, tid, + offsetof (struct user, u_debugreg[regnum]), 0); + if (errno != 0) +#if 0 + perror_with_name ("Couldn't read debug register"); +#else + return 0; +#endif - (We can't use the generic version of this function in - core-regset.c, because Linux has *three* different kinds of - register set notes. core-regset.c would have to call - supply_fpxregset, which most platforms don't have.) + return value; +} - CORE_REG_SECT points to an array of bytes, which are the contents - of a `note' from a core file which BFD thinks might contain - register contents. CORE_REG_SIZE is its size. +static void +i386_linux_dr_set (int regnum, unsigned long value) +{ + int tid; - WHICH says which register set corelow suspects this is: - 0 --- the general-purpose register set, in elf_gregset_t format - 2 --- the floating-point register set, in elf_fpregset_t format - 3 --- the extended floating-point register set, in elf_fpxregset_t format + /* FIXME: kettenis/2001-01-29: It's not clear what we should do with + multi-threaded processes here. For now, pretend there is just + one thread. */ + tid = PIDGET (inferior_ptid); - REG_ADDR isn't used on Linux. */ + errno = 0; + ptrace (PTRACE_POKEUSER, tid, + offsetof (struct user, u_debugreg[regnum]), value); + if (errno != 0) + perror_with_name ("Couldn't write debug register"); +} -static void -fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, - int which, CORE_ADDR reg_addr) +void +i386_linux_dr_set_control (unsigned long control) { - elf_gregset_t gregset; - elf_fpregset_t fpregset; + i386_linux_dr_set (DR_CONTROL, control); +} - switch (which) - { - case 0: - if (core_reg_size != sizeof (gregset)) - warning ("Wrong size gregset in core file."); - else - { - memcpy (&gregset, core_reg_sect, sizeof (gregset)); - supply_gregset (&gregset); - } - break; +void +i386_linux_dr_set_addr (int regnum, CORE_ADDR addr) +{ + gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); - case 2: - if (core_reg_size != sizeof (fpregset)) - warning ("Wrong size fpregset in core file."); - else - { - memcpy (&fpregset, core_reg_sect, sizeof (fpregset)); - supply_fpregset (&fpregset); - } - break; + i386_linux_dr_set (DR_FIRSTADDR + regnum, addr); +} -#ifdef HAVE_PTRACE_GETFPXREGS - { - elf_fpxregset_t fpxregset; - - case 3: - if (core_reg_size != sizeof (fpxregset)) - warning ("Wrong size fpxregset in core file."); - else - { - memcpy (&fpxregset, core_reg_sect, sizeof (fpxregset)); - supply_fpxregset (&fpxregset); - } - break; - } +void +i386_linux_dr_reset_addr (int regnum) +{ + gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); + + i386_linux_dr_set (DR_FIRSTADDR + regnum, 0L); +} + +unsigned long +i386_linux_dr_get_status (void) +{ + return i386_linux_dr_get (DR_STATUS); +} + + +/* Called by libthread_db. Returns a pointer to the thread local + storage (or its descriptor). */ + +ps_err_e +ps_get_thread_area (const struct ps_prochandle *ph, + lwpid_t lwpid, int idx, void **base) +{ + /* NOTE: cagney/2003-08-26: The definition of this buffer is found + in the kernel header . It, after padding, is 4 x + 4 byte integers in size: `entry_number', `base_addr', `limit', + and a bunch of status bits. + + The values returned by this ptrace call should be part of the + regcache buffer, and ps_get_thread_area should channel its + request through the regcache. That way remote targets could + provide the value using the remote protocol and not this direct + call. + + Is this function needed? I'm guessing that the `base' is the + address of a a descriptor that libthread_db uses to find the + thread local address base that GDB needs. Perhaps that + descriptor is defined by the ABI. Anyway, given that + libthread_db calls this function without prompting (gdb + requesting tls base) I guess it needs info in there anyway. */ + unsigned int desc[4]; + gdb_assert (sizeof (int) == 4); + +#ifndef PTRACE_GET_THREAD_AREA +#define PTRACE_GET_THREAD_AREA 25 #endif - default: - /* We've covered all the kinds of registers we know about here, - so this must be something we wouldn't know what to do with - anyway. Just ignore it. */ - break; - } + if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, + (void *) idx, (unsigned long) &desc) < 0) + return PS_ERR; + + *(int *)base = desc[1]; + return PS_OK; } -/* The instruction for a Linux system call is: +/* The instruction for a GNU/Linux system call is: int $0x80 or 0xcd 0x80. */ @@ -741,19 +788,21 @@ static const unsigned char linux_syscall[] = { 0xcd, 0x80 }; 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 pid = PIDGET (ptid); + int request = PTRACE_CONT; if (pid == -1) /* Resume all threads. */ /* 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; + all threads" and "resume inferior_ptid" are the same. */ + pid = PIDGET (inferior_ptid); if (step) { - CORE_ADDR pc = read_pc_pid (pid); + CORE_ADDR pc = read_pc_pid (pid_to_ptid (pid)); unsigned char buf[LINUX_SYSCALL_LEN]; request = PTRACE_SINGLESTEP; @@ -767,18 +816,19 @@ child_resume (int pid, int step, enum target_signal signal) that's about to be restored, and set the trace flag there. */ /* First check if PC is at a system call. */ - if (read_memory_nobpt (pc, (char *) buf, LINUX_SYSCALL_LEN) == 0 + if (deprecated_read_memory_nobpt (pc, (char *) buf, LINUX_SYSCALL_LEN) == 0 && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0) { - int syscall = read_register_pid (LINUX_SYSCALL_REGNUM, pid); + int syscall = read_register_pid (LINUX_SYSCALL_REGNUM, + pid_to_ptid (pid)); /* Then check the system call number. */ if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn) { - CORE_ADDR sp = read_register (SP_REGNUM); + CORE_ADDR sp = read_register (I386_ESP_REGNUM); CORE_ADDR addr = sp; unsigned long int eflags; - + if (syscall == SYS_rt_sigreturn) addr = read_memory_integer (sp + 8, 4) + 20; @@ -795,113 +845,10 @@ child_resume (int pid, int step, enum target_signal signal) if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1) perror_with_name ("ptrace"); } - - -/* Calling functions in shared libraries. */ -/* FIXME: kettenis/2000-03-05: Doesn't this belong in a - target-dependent file? The function - `i386_linux_skip_solib_resolver' is mentioned in - `config/i386/tm-linux.h'. */ - -/* Find the minimal symbol named NAME, and return both the minsym - struct and its objfile. This probably ought to be in minsym.c, but - everything there is trying to deal with things like C++ and - SOFUN_ADDRESS_MAYBE_TURQUOISE, ... Since this is so simple, it may - be considered too special-purpose for general consumption. */ - -static struct minimal_symbol * -find_minsym_and_objfile (char *name, struct objfile **objfile_p) -{ - struct objfile *objfile; - - ALL_OBJFILES (objfile) - { - struct minimal_symbol *msym; - - ALL_OBJFILE_MSYMBOLS (objfile, msym) - { - if (SYMBOL_NAME (msym) - && STREQ (SYMBOL_NAME (msym), name)) - { - *objfile_p = objfile; - return msym; - } - } - } - - return 0; -} - -static CORE_ADDR -skip_hurd_resolver (CORE_ADDR pc) -{ - /* The HURD dynamic linker is part of the GNU C library, so many - GNU/Linux distributions use it. (All ELF versions, as far as I - know.) An unresolved PLT entry points to "_dl_runtime_resolve", - which calls "fixup" to patch the PLT, and then passes control to - the function. - - We look for the symbol `_dl_runtime_resolve', and find `fixup' in - the same objfile. If we are at the entry point of `fixup', then - we set a breakpoint at the return address (at the top of the - stack), and continue. - - It's kind of gross to do all these checks every time we're - called, since they don't change once the executable has gotten - started. But this is only a temporary hack --- upcoming versions - of Linux will provide a portable, efficient interface for - debugging programs that use shared libraries. */ - - struct objfile *objfile; - struct minimal_symbol *resolver - = find_minsym_and_objfile ("_dl_runtime_resolve", &objfile); - - if (resolver) - { - struct minimal_symbol *fixup - = lookup_minimal_symbol ("fixup", 0, objfile); - - if (fixup && SYMBOL_VALUE_ADDRESS (fixup) == pc) - return (SAVED_PC_AFTER_CALL (get_current_frame ())); - } - - return 0; -} - -/* See the comments for SKIP_SOLIB_RESOLVER at the top of infrun.c. - This function: - 1) decides whether a PLT has sent us into the linker to resolve - a function reference, and - 2) if so, tells us where to set a temporary breakpoint that will - trigger when the dynamic linker is done. */ - -CORE_ADDR -i386_linux_skip_solib_resolver (CORE_ADDR pc) -{ - CORE_ADDR result; - - /* Plug in functions for other kinds of resolvers here. */ - result = skip_hurd_resolver (pc); - if (result) - return result; - - return 0; -} - - -/* Register that we are able to handle Linux ELF core file formats. */ - -static struct core_fns linux_elf_core_fns = -{ - bfd_target_elf_flavour, /* core_flavour */ - default_check_format, /* check_format */ - default_core_sniffer, /* core_sniffer */ - fetch_core_registers, /* core_read_registers */ - NULL /* next */ -}; void -_initialize_i386_linux_nat (void) +child_post_startup_inferior (ptid_t ptid) { - add_core_fns (&linux_elf_core_fns); + i386_cleanup_dregs (); + linux_child_post_startup_inferior (ptid); }