X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fi386-linux-nat.c;h=dd8f141f23b118018a31aad4ca3889d0ecae436a;hb=2480b6fa946bb2d2dc993b1c4a83a8e1258a75e8;hp=5a5cf8d328cc88777be9ef4328bf04c801a51442;hpb=875f8d0e3a0a1a550502f906bbca0892004c8caa;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/i386-linux-nat.c b/gdb/i386-linux-nat.c index 5a5cf8d328..dd8f141f23 100644 --- a/gdb/i386-linux-nat.c +++ b/gdb/i386-linux-nat.c @@ -1,7 +1,6 @@ /* Native-dependent code for GNU/Linux i386. - Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 - Free Software Foundation, Inc. + Copyright (C) 1999-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -22,53 +21,33 @@ #include "inferior.h" #include "gdbcore.h" #include "regcache.h" -#include "target.h" -#include "linux-nat.h" - -#include "gdb_assert.h" -#include "gdb_string.h" -#include -#include -#include - -#ifdef HAVE_SYS_REG_H -#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 "elf/common.h" +#include "nat/gdb_ptrace.h" +#include #include "gregset.h" +#include "gdb_proc_service.h" +#include "i386-linux-nat.h" #include "i387-tdep.h" #include "i386-tdep.h" #include "i386-linux-tdep.h" +#include "gdbsupport/x86-xstate.h" -/* Defines ps_err_e, struct ps_prochandle. */ -#include "gdb_proc_service.h" - +#include "x86-linux-nat.h" +#include "nat/linux-ptrace.h" +#include "inf-ptrace.h" + +struct i386_linux_nat_target final : public x86_linux_nat_target +{ + /* Add our register access methods. */ + void fetch_registers (struct regcache *, int) override; + void store_registers (struct regcache *, int) override; + + /* Override the default ptrace resume method. */ + void low_resume (ptid_t ptid, int step, enum gdb_signal sig) override; +}; + +static i386_linux_nat_target the_i386_linux_nat_target; /* 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 @@ -82,24 +61,6 @@ those names are now used for the register sets used in the `mcontext_t' type, and have a different size and layout. */ -/* Mapping between the general-purpose registers in `struct user' - format and GDB's register array layout. */ -static int regmap[] = -{ - EAX, ECX, EDX, EBX, - UESP, EBP, ESI, EDI, - EIP, EFL, CS, SS, - 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. */ @@ -109,6 +70,9 @@ static int regmap[] = #define GETFPXREGS_SUPPLIES(regno) \ (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS) +#define GETXSTATEREGS_SUPPLIES(regno) \ + (I386_ST0_REGNUM <= (regno) && (regno) < I386_PKEYS_NUM_REGS) + /* Does the current host support the GETREGS request? */ int have_ptrace_getregs = #ifdef HAVE_PTRACE_GETREGS @@ -128,7 +92,7 @@ int have_ptrace_getregs = for this to be a simple variable. */ int have_ptrace_getfpxregs = #ifdef HAVE_PTRACE_GETFPXREGS - 1 + -1 #else 0 #endif @@ -142,54 +106,50 @@ int have_ptrace_getfpxregs = static void fetch_register (struct regcache *regcache, int regno) { - int tid; + pid_t tid; int val; gdb_assert (!have_ptrace_getregs); - if (regmap[regno] == -1) + if (i386_linux_gregset_reg_offset[regno] == -1) { - regcache_raw_supply (regcache, regno, NULL); + regcache->raw_supply (regno, NULL); 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. */ + tid = get_ptrace_pid (regcache->ptid ()); errno = 0; - val = ptrace (PTRACE_PEEKUSER, tid, 4 * regmap[regno], 0); + val = ptrace (PTRACE_PEEKUSER, tid, + i386_linux_gregset_reg_offset[regno], 0); if (errno != 0) error (_("Couldn't read register %s (#%d): %s."), - gdbarch_register_name (get_regcache_arch (regcache), regno), + gdbarch_register_name (regcache->arch (), regno), regno, safe_strerror (errno)); - regcache_raw_supply (regcache, regno, &val); + regcache->raw_supply (regno, &val); } -/* Store one register. */ +/* Store one register. */ static void store_register (const struct regcache *regcache, int regno) { - int tid; + pid_t tid; int val; gdb_assert (!have_ptrace_getregs); - if (regmap[regno] == -1) + if (i386_linux_gregset_reg_offset[regno] == -1) 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. */ + tid = get_ptrace_pid (regcache->ptid ()); errno = 0; - regcache_raw_collect (regcache, regno, &val); - ptrace (PTRACE_POKEUSER, tid, 4 * regmap[regno], val); + regcache->raw_collect (regno, &val); + ptrace (PTRACE_POKEUSER, tid, + i386_linux_gregset_reg_offset[regno], val); if (errno != 0) error (_("Couldn't write register %s (#%d): %s."), - gdbarch_register_name (get_regcache_arch (regcache), regno), + gdbarch_register_name (regcache->arch (), regno), regno, safe_strerror (errno)); } @@ -203,16 +163,17 @@ store_register (const struct regcache *regcache, int regno) void supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp) { - const elf_greg_t *regp = (const elf_greg_t *) gregsetp; + const gdb_byte *regp = (const gdb_byte *) gregsetp; int i; for (i = 0; i < I386_NUM_GREGS; i++) - regcache_raw_supply (regcache, i, regp + regmap[i]); + regcache->raw_supply (i, regp + i386_linux_gregset_reg_offset[i]); if (I386_LINUX_ORIG_EAX_REGNUM - < gdbarch_num_regs (get_regcache_arch (regcache))) - regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM, - regp + ORIG_EAX); + < gdbarch_num_regs (regcache->arch ())) + regcache->raw_supply + (I386_LINUX_ORIG_EAX_REGNUM, + regp + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]); } /* Fill register REGNO (if it is a general-purpose register) in @@ -223,18 +184,19 @@ void fill_gregset (const struct regcache *regcache, elf_gregset_t *gregsetp, int regno) { - elf_greg_t *regp = (elf_greg_t *) gregsetp; + gdb_byte *regp = (gdb_byte *) gregsetp; int i; for (i = 0; i < I386_NUM_GREGS; i++) if (regno == -1 || regno == i) - regcache_raw_collect (regcache, i, regp + regmap[i]); + regcache->raw_collect (i, regp + i386_linux_gregset_reg_offset[i]); if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM) && I386_LINUX_ORIG_EAX_REGNUM - < gdbarch_num_regs (get_regcache_arch (regcache))) - regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM, - regp + ORIG_EAX); + < gdbarch_num_regs (regcache->arch ())) + regcache->raw_collect + (I386_LINUX_ORIG_EAX_REGNUM, + regp + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]); } #ifdef HAVE_PTRACE_GETREGS @@ -346,37 +308,74 @@ store_fpregs (const struct regcache *regcache, int tid, int regno) #else -static void fetch_fpregs (struct regcache *regcache, int tid) {} -static void store_fpregs (const struct regcache *regcache, int tid, int regno) {} +static void +fetch_fpregs (struct regcache *regcache, int tid) +{ +} + +static void +store_fpregs (const struct regcache *regcache, int tid, int regno) +{ +} #endif /* Transfering floating-point and SSE registers to and from GDB. */ -#ifdef HAVE_PTRACE_GETFPXREGS - -/* Fill GDB's register array with the floating-point and SSE register - values in *FPXREGSETP. */ +/* Fetch all registers covered by the PTRACE_GETREGSET request from + process/thread TID and store their values in GDB's register array. + Return non-zero if successful, zero otherwise. */ -void -supply_fpxregset (struct regcache *regcache, - const elf_fpxregset_t *fpxregsetp) +static int +fetch_xstateregs (struct regcache *regcache, int tid) { - i387_supply_fxsave (regcache, -1, fpxregsetp); + char xstateregs[X86_XSTATE_MAX_SIZE]; + struct iovec iov; + + if (have_ptrace_getregset != TRIBOOL_TRUE) + return 0; + + iov.iov_base = xstateregs; + iov.iov_len = sizeof(xstateregs); + if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE, + &iov) < 0) + perror_with_name (_("Couldn't read extended state status")); + + i387_supply_xsave (regcache, -1, xstateregs); + return 1; } -/* 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. */ +/* Store all valid registers in GDB's register array covered by the + PTRACE_SETREGSET request into the process/thread specified by TID. + Return non-zero if successful, zero otherwise. */ -void -fill_fpxregset (const struct regcache *regcache, - elf_fpxregset_t *fpxregsetp, int regno) +static int +store_xstateregs (const struct regcache *regcache, int tid, int regno) { - i387_collect_fxsave (regcache, regno, fpxregsetp); + char xstateregs[X86_XSTATE_MAX_SIZE]; + struct iovec iov; + + if (have_ptrace_getregset != TRIBOOL_TRUE) + return 0; + + iov.iov_base = xstateregs; + iov.iov_len = sizeof(xstateregs); + if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE, + &iov) < 0) + perror_with_name (_("Couldn't read extended state status")); + + i387_collect_xsave (regcache, regno, xstateregs, 0); + + if (ptrace (PTRACE_SETREGSET, tid, (unsigned int) NT_X86_XSTATE, + (int) &iov) < 0) + perror_with_name (_("Couldn't write extended state status")); + + return 1; } +#ifdef HAVE_PTRACE_GETFPXREGS + /* Fetch all registers covered by the PTRACE_GETFPXREGS request from process/thread TID and store their values in GDB's register array. Return non-zero if successful, zero otherwise. */ @@ -400,7 +399,7 @@ fetch_fpxregs (struct regcache *regcache, int tid) perror_with_name (_("Couldn't read floating-point and SSE registers")); } - supply_fpxregset (regcache, (const elf_fpxregset_t *) &fpxregs); + i387_supply_fxsave (regcache, -1, (const elf_fpxregset_t *) &fpxregs); return 1; } @@ -427,7 +426,7 @@ store_fpxregs (const struct regcache *regcache, int tid, int regno) perror_with_name (_("Couldn't read floating-point and SSE registers")); } - fill_fpxregset (regcache, &fpxregs, regno); + i387_collect_fxsave (regcache, regno, &fpxregs); if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1) perror_with_name (_("Couldn't write floating-point and SSE registers")); @@ -437,8 +436,17 @@ store_fpxregs (const struct regcache *regcache, int tid, int regno) #else -static int fetch_fpxregs (struct regcache *regcache, int tid) { return 0; } -static int store_fpxregs (const struct regcache *regcache, int tid, int regno) { return 0; } +static int +fetch_fpxregs (struct regcache *regcache, int tid) +{ + return 0; +} + +static int +store_fpxregs (const struct regcache *regcache, int tid, int regno) +{ + return 0; +} #endif /* HAVE_PTRACE_GETFPXREGS */ @@ -449,10 +457,10 @@ static int store_fpxregs (const struct regcache *regcache, int tid, int regno) { this for all registers (including the floating point and SSE registers). */ -static void -i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno) +void +i386_linux_nat_target::fetch_registers (struct regcache *regcache, int regno) { - int tid; + pid_t tid; /* Use the old method of peeking around in `struct user' if the GETREGS request isn't available. */ @@ -460,17 +468,14 @@ i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno) { int i; - for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) + for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++) if (regno == -1 || regno == i) fetch_register (regcache, i); 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. */ + tid = get_ptrace_pid (regcache->ptid ()); /* Use the PTRACE_GETFPXREGS request whenever possible, since it transfers more registers in one system call, and we'll cache the @@ -483,10 +488,12 @@ i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno) /* The call above might reset `have_ptrace_getregs'. */ if (!have_ptrace_getregs) { - i386_linux_fetch_inferior_registers (regcache, regno); + fetch_registers (regcache, regno); return; } + if (fetch_xstateregs (regcache, tid)) + return; if (fetch_fpxregs (regcache, tid)) return; fetch_fpregs (regcache, tid); @@ -499,6 +506,12 @@ i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno) return; } + if (GETXSTATEREGS_SUPPLIES (regno)) + { + if (fetch_xstateregs (regcache, tid)) + return; + } + if (GETFPXREGS_SUPPLIES (regno)) { if (fetch_fpxregs (regcache, tid)) @@ -521,10 +534,10 @@ i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno) /* Store register REGNO back into the child process. If REGNO is -1, do this for all registers (including the floating point and SSE registers). */ -static void -i386_linux_store_inferior_registers (struct regcache *regcache, int regno) +void +i386_linux_nat_target::store_registers (struct regcache *regcache, int regno) { - int tid; + pid_t tid; /* Use the old method of poking around in `struct user' if the SETREGS request isn't available. */ @@ -532,17 +545,14 @@ i386_linux_store_inferior_registers (struct regcache *regcache, int regno) { int i; - for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++) + for (i = 0; i < gdbarch_num_regs (regcache->arch ()); i++) if (regno == -1 || regno == i) store_register (regcache, i); 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. */ + tid = get_ptrace_pid (regcache->ptid ()); /* Use the PTRACE_SETFPXREGS requests whenever possible, since it transfers more registers in one system call. But remember that @@ -550,6 +560,8 @@ i386_linux_store_inferior_registers (struct regcache *regcache, int regno) if (regno == -1) { store_regs (regcache, tid, regno); + if (store_xstateregs (regcache, tid, regno)) + return; if (store_fpxregs (regcache, tid, regno)) return; store_fpregs (regcache, tid, regno); @@ -562,6 +574,12 @@ i386_linux_store_inferior_registers (struct regcache *regcache, int regno) return; } + if (GETXSTATEREGS_SUPPLIES (regno)) + { + if (store_xstateregs (regcache, tid, regno)) + return; + } + if (GETFPXREGS_SUPPLIES (regno)) { if (store_fpxregs (regcache, tid, regno)) @@ -579,139 +597,22 @@ i386_linux_store_inferior_registers (struct regcache *regcache, int regno) } -/* Support for debug registers. */ - -static unsigned long i386_linux_dr[DR_CONTROL + 1]; - -static unsigned long -i386_linux_dr_get (ptid_t ptid, int regnum) -{ - int tid; - unsigned long value; - - tid = TIDGET (ptid); - if (tid == 0) - tid = PIDGET (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 vector. 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 - - return value; -} - -static void -i386_linux_dr_set (ptid_t ptid, int regnum, unsigned long value) -{ - int tid; - - tid = TIDGET (ptid); - if (tid == 0) - tid = PIDGET (ptid); - - errno = 0; - ptrace (PTRACE_POKEUSER, tid, - offsetof (struct user, u_debugreg[regnum]), value); - if (errno != 0) - perror_with_name (_("Couldn't write debug register")); -} - -void -i386_linux_dr_set_control (unsigned long control) -{ - struct lwp_info *lp; - ptid_t ptid; - - i386_linux_dr[DR_CONTROL] = control; - ALL_LWPS (lp, ptid) - i386_linux_dr_set (ptid, DR_CONTROL, control); -} - -void -i386_linux_dr_set_addr (int regnum, CORE_ADDR addr) -{ - struct lwp_info *lp; - ptid_t ptid; - - gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); - - i386_linux_dr[DR_FIRSTADDR + regnum] = addr; - ALL_LWPS (lp, ptid) - i386_linux_dr_set (ptid, DR_FIRSTADDR + regnum, addr); -} - -void -i386_linux_dr_reset_addr (int regnum) -{ - i386_linux_dr_set_addr (regnum, 0); -} - -unsigned long -i386_linux_dr_get_status (void) -{ - return i386_linux_dr_get (inferior_ptid, DR_STATUS); -} - -static void -i386_linux_new_thread (ptid_t ptid) -{ - int i; - - for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++) - i386_linux_dr_set (ptid, i, i386_linux_dr[i]); - - i386_linux_dr_set (ptid, DR_CONTROL, i386_linux_dr[DR_CONTROL]); -} - - /* 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, +ps_get_thread_area (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 + unsigned int base_addr; + ps_err_e result; + + result = x86_linux_get_thread_area (lwpid, (void *) idx, &base_addr); - if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, - (void *) idx, (unsigned long) &desc) < 0) - return PS_ERR; + if (result == PS_OK) + *(int *) base = base_addr; - *(int *)base = desc[1]; - return PS_OK; + return result; } @@ -743,23 +644,29 @@ static const unsigned char linux_syscall[] = { 0xcd, 0x80 }; If STEP is nonzero, single-step it. If SIGNAL is nonzero, give it that signal. */ -static void -i386_linux_resume (ptid_t ptid, int step, enum target_signal signal) +void +i386_linux_nat_target::low_resume (ptid_t ptid, int step, enum gdb_signal signal) { - int pid = PIDGET (ptid); + int pid = ptid.lwp (); + int request; - int request = PTRACE_CONT; + if (catch_syscall_enabled () > 0) + request = PTRACE_SYSCALL; + else + request = PTRACE_CONT; if (step) { - struct regcache *regcache = get_thread_regcache (pid_to_ptid (pid)); + struct regcache *regcache = get_thread_regcache (ptid); + struct gdbarch *gdbarch = regcache->arch (); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); ULONGEST pc; gdb_byte buf[LINUX_SYSCALL_LEN]; request = PTRACE_SINGLESTEP; - regcache_cooked_read_unsigned - (regcache, gdbarch_pc_regnum (get_regcache_arch (regcache)), &pc); + regcache_cooked_read_unsigned (regcache, + gdbarch_pc_regnum (gdbarch), &pc); /* Returning from a signal trampoline is done by calling a special system call (sigreturn or rt_sigreturn, see @@ -770,7 +677,7 @@ i386_linux_resume (ptid_t ptid, 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, buf, LINUX_SYSCALL_LEN) == 0 + if (target_read_memory (pc, buf, LINUX_SYSCALL_LEN) == 0 && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0) { ULONGEST syscall; @@ -785,7 +692,8 @@ i386_linux_resume (ptid_t ptid, int step, enum target_signal signal) regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp); if (syscall == SYS_rt_sigreturn) - addr = read_memory_integer (sp + 8, 4) + 20; + addr = read_memory_unsigned_integer (sp + 8, 4, byte_order) + + 20; else addr = sp; @@ -799,39 +707,15 @@ i386_linux_resume (ptid_t ptid, int step, enum target_signal signal) } } - if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1) + if (ptrace (request, pid, 0, gdb_signal_to_host (signal)) == -1) perror_with_name (("ptrace")); } -static void (*super_post_startup_inferior) (ptid_t ptid); - -static void -i386_linux_child_post_startup_inferior (ptid_t ptid) -{ - i386_cleanup_dregs (); - super_post_startup_inferior (ptid); -} - void _initialize_i386_linux_nat (void) { - struct target_ops *t; - - /* Fill in the generic GNU/Linux methods. */ - t = linux_target (); - - /* Override the default ptrace resume method. */ - t->to_resume = i386_linux_resume; - - /* Override the GNU/Linux inferior startup hook. */ - super_post_startup_inferior = t->to_post_startup_inferior; - t->to_post_startup_inferior = i386_linux_child_post_startup_inferior; - - /* Add our register access methods. */ - t->to_fetch_registers = i386_linux_fetch_inferior_registers; - t->to_store_registers = i386_linux_store_inferior_registers; + linux_target = &the_i386_linux_nat_target; - /* Register the target. */ - linux_nat_add_target (t); - linux_nat_set_new_thread (t, i386_linux_new_thread); + /* Add the target. */ + add_inf_child_target (linux_target); }