Automatic date update in version.in
[platform/upstream/binutils.git] / gdb / i386-linux-nat.c
1 /* Native-dependent code for GNU/Linux i386.
2
3    Copyright (C) 1999-2014 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "inferior.h"
22 #include "gdbcore.h"
23 #include "regcache.h"
24 #include "elf/common.h"
25 #include <sys/ptrace.h>
26 #include <sys/uio.h>
27 #include "gregset.h"
28 #include "gdb_proc_service.h"
29
30 #include "i386-linux-nat.h"
31 #include "i387-tdep.h"
32 #include "i386-tdep.h"
33 #include "i386-linux-tdep.h"
34 #include "x86-xstate.h"
35
36 #include "x86-linux-nat.h"
37
38 /* The register sets used in GNU/Linux ELF core-dumps are identical to
39    the register sets in `struct user' that is used for a.out
40    core-dumps, and is also used by `ptrace'.  The corresponding types
41    are `elf_gregset_t' for the general-purpose registers (with
42    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
43    for the floating-point registers.
44
45    Those types used to be available under the names `gregset_t' and
46    `fpregset_t' too, and this file used those names in the past.  But
47    those names are now used for the register sets used in the
48    `mcontext_t' type, and have a different size and layout.  */
49
50 /* Which ptrace request retrieves which registers?
51    These apply to the corresponding SET requests as well.  */
52
53 #define GETREGS_SUPPLIES(regno) \
54   ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
55
56 #define GETFPXREGS_SUPPLIES(regno) \
57   (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS)
58
59 #define GETXSTATEREGS_SUPPLIES(regno) \
60   (I386_ST0_REGNUM <= (regno) && (regno) < I386_AVX512_NUM_REGS)
61
62 /* Does the current host support the GETREGS request?  */
63 int have_ptrace_getregs =
64 #ifdef HAVE_PTRACE_GETREGS
65   1
66 #else
67   0
68 #endif
69 ;
70
71 /* Does the current host support the GETFPXREGS request?  The header
72    file may or may not define it, and even if it is defined, the
73    kernel will return EIO if it's running on a pre-SSE processor.
74
75    My instinct is to attach this to some architecture- or
76    target-specific data structure, but really, a particular GDB
77    process can only run on top of one kernel at a time.  So it's okay
78    for this to be a simple variable.  */
79 int have_ptrace_getfpxregs =
80 #ifdef HAVE_PTRACE_GETFPXREGS
81   -1
82 #else
83   0
84 #endif
85 ;
86 \f
87
88 /* Accessing registers through the U area, one at a time.  */
89
90 /* Fetch one register.  */
91
92 static void
93 fetch_register (struct regcache *regcache, int regno)
94 {
95   int tid;
96   int val;
97
98   gdb_assert (!have_ptrace_getregs);
99   if (i386_linux_gregset_reg_offset[regno] == -1)
100     {
101       regcache_raw_supply (regcache, regno, NULL);
102       return;
103     }
104
105   /* GNU/Linux LWP ID's are process ID's.  */
106   tid = ptid_get_lwp (inferior_ptid);
107   if (tid == 0)
108     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
109
110   errno = 0;
111   val = ptrace (PTRACE_PEEKUSER, tid,
112                 i386_linux_gregset_reg_offset[regno], 0);
113   if (errno != 0)
114     error (_("Couldn't read register %s (#%d): %s."), 
115            gdbarch_register_name (get_regcache_arch (regcache), regno),
116            regno, safe_strerror (errno));
117
118   regcache_raw_supply (regcache, regno, &val);
119 }
120
121 /* Store one register.  */
122
123 static void
124 store_register (const struct regcache *regcache, int regno)
125 {
126   int tid;
127   int val;
128
129   gdb_assert (!have_ptrace_getregs);
130   if (i386_linux_gregset_reg_offset[regno] == -1)
131     return;
132
133   /* GNU/Linux LWP ID's are process ID's.  */
134   tid = ptid_get_lwp (inferior_ptid);
135   if (tid == 0)
136     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
137
138   errno = 0;
139   regcache_raw_collect (regcache, regno, &val);
140   ptrace (PTRACE_POKEUSER, tid,
141           i386_linux_gregset_reg_offset[regno], val);
142   if (errno != 0)
143     error (_("Couldn't write register %s (#%d): %s."),
144            gdbarch_register_name (get_regcache_arch (regcache), regno),
145            regno, safe_strerror (errno));
146 }
147 \f
148
149 /* Transfering the general-purpose registers between GDB, inferiors
150    and core files.  */
151
152 /* Fill GDB's register array with the general-purpose register values
153    in *GREGSETP.  */
154
155 void
156 supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp)
157 {
158   const gdb_byte *regp = (const gdb_byte *) gregsetp;
159   int i;
160
161   for (i = 0; i < I386_NUM_GREGS; i++)
162     regcache_raw_supply (regcache, i,
163                          regp + i386_linux_gregset_reg_offset[i]);
164
165   if (I386_LINUX_ORIG_EAX_REGNUM
166         < gdbarch_num_regs (get_regcache_arch (regcache)))
167     regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
168                          + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
169 }
170
171 /* Fill register REGNO (if it is a general-purpose register) in
172    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
173    do this for all registers.  */
174
175 void
176 fill_gregset (const struct regcache *regcache,
177               elf_gregset_t *gregsetp, int regno)
178 {
179   gdb_byte *regp = (gdb_byte *) gregsetp;
180   int i;
181
182   for (i = 0; i < I386_NUM_GREGS; i++)
183     if (regno == -1 || regno == i)
184       regcache_raw_collect (regcache, i,
185                             regp + i386_linux_gregset_reg_offset[i]);
186
187   if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
188       && I386_LINUX_ORIG_EAX_REGNUM
189            < gdbarch_num_regs (get_regcache_arch (regcache)))
190     regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM, regp
191                           + i386_linux_gregset_reg_offset[I386_LINUX_ORIG_EAX_REGNUM]);
192 }
193
194 #ifdef HAVE_PTRACE_GETREGS
195
196 /* Fetch all general-purpose registers from process/thread TID and
197    store their values in GDB's register array.  */
198
199 static void
200 fetch_regs (struct regcache *regcache, int tid)
201 {
202   elf_gregset_t regs;
203   elf_gregset_t *regs_p = &regs;
204
205   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
206     {
207       if (errno == EIO)
208         {
209           /* The kernel we're running on doesn't support the GETREGS
210              request.  Reset `have_ptrace_getregs'.  */
211           have_ptrace_getregs = 0;
212           return;
213         }
214
215       perror_with_name (_("Couldn't get registers"));
216     }
217
218   supply_gregset (regcache, (const elf_gregset_t *) regs_p);
219 }
220
221 /* Store all valid general-purpose registers in GDB's register array
222    into the process/thread specified by TID.  */
223
224 static void
225 store_regs (const struct regcache *regcache, int tid, int regno)
226 {
227   elf_gregset_t regs;
228
229   if (ptrace (PTRACE_GETREGS, tid, 0, (int) &regs) < 0)
230     perror_with_name (_("Couldn't get registers"));
231
232   fill_gregset (regcache, &regs, regno);
233   
234   if (ptrace (PTRACE_SETREGS, tid, 0, (int) &regs) < 0)
235     perror_with_name (_("Couldn't write registers"));
236 }
237
238 #else
239
240 static void fetch_regs (struct regcache *regcache, int tid) {}
241 static void store_regs (const struct regcache *regcache, int tid, int regno) {}
242
243 #endif
244 \f
245
246 /* Transfering floating-point registers between GDB, inferiors and cores.  */
247
248 /* Fill GDB's register array with the floating-point register values in
249    *FPREGSETP.  */
250
251 void 
252 supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp)
253 {
254   i387_supply_fsave (regcache, -1, fpregsetp);
255 }
256
257 /* Fill register REGNO (if it is a floating-point register) in
258    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
259    do this for all registers.  */
260
261 void
262 fill_fpregset (const struct regcache *regcache,
263                elf_fpregset_t *fpregsetp, int regno)
264 {
265   i387_collect_fsave (regcache, regno, fpregsetp);
266 }
267
268 #ifdef HAVE_PTRACE_GETREGS
269
270 /* Fetch all floating-point registers from process/thread TID and store
271    thier values in GDB's register array.  */
272
273 static void
274 fetch_fpregs (struct regcache *regcache, int tid)
275 {
276   elf_fpregset_t fpregs;
277
278   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
279     perror_with_name (_("Couldn't get floating point status"));
280
281   supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs);
282 }
283
284 /* Store all valid floating-point registers in GDB's register array
285    into the process/thread specified by TID.  */
286
287 static void
288 store_fpregs (const struct regcache *regcache, int tid, int regno)
289 {
290   elf_fpregset_t fpregs;
291
292   if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
293     perror_with_name (_("Couldn't get floating point status"));
294
295   fill_fpregset (regcache, &fpregs, regno);
296
297   if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
298     perror_with_name (_("Couldn't write floating point status"));
299 }
300
301 #else
302
303 static void
304 fetch_fpregs (struct regcache *regcache, int tid)
305 {
306 }
307
308 static void
309 store_fpregs (const struct regcache *regcache, int tid, int regno)
310 {
311 }
312
313 #endif
314 \f
315
316 /* Transfering floating-point and SSE registers to and from GDB.  */
317
318 /* Fetch all registers covered by the PTRACE_GETREGSET request from
319    process/thread TID and store their values in GDB's register array.
320    Return non-zero if successful, zero otherwise.  */
321
322 static int
323 fetch_xstateregs (struct regcache *regcache, int tid)
324 {
325   char xstateregs[X86_XSTATE_MAX_SIZE];
326   struct iovec iov;
327
328   if (!have_ptrace_getregset)
329     return 0;
330
331   iov.iov_base = xstateregs;
332   iov.iov_len = sizeof(xstateregs);
333   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
334               &iov) < 0)
335     perror_with_name (_("Couldn't read extended state status"));
336
337   i387_supply_xsave (regcache, -1, xstateregs);
338   return 1;
339 }
340
341 /* Store all valid registers in GDB's register array covered by the
342    PTRACE_SETREGSET request into the process/thread specified by TID.
343    Return non-zero if successful, zero otherwise.  */
344
345 static int
346 store_xstateregs (const struct regcache *regcache, int tid, int regno)
347 {
348   char xstateregs[X86_XSTATE_MAX_SIZE];
349   struct iovec iov;
350
351   if (!have_ptrace_getregset)
352     return 0;
353   
354   iov.iov_base = xstateregs;
355   iov.iov_len = sizeof(xstateregs);
356   if (ptrace (PTRACE_GETREGSET, tid, (unsigned int) NT_X86_XSTATE,
357               &iov) < 0)
358     perror_with_name (_("Couldn't read extended state status"));
359
360   i387_collect_xsave (regcache, regno, xstateregs, 0);
361
362   if (ptrace (PTRACE_SETREGSET, tid, (unsigned int) NT_X86_XSTATE,
363               (int) &iov) < 0)
364     perror_with_name (_("Couldn't write extended state status"));
365
366   return 1;
367 }
368
369 #ifdef HAVE_PTRACE_GETFPXREGS
370
371 /* Fetch all registers covered by the PTRACE_GETFPXREGS request from
372    process/thread TID and store their values in GDB's register array.
373    Return non-zero if successful, zero otherwise.  */
374
375 static int
376 fetch_fpxregs (struct regcache *regcache, int tid)
377 {
378   elf_fpxregset_t fpxregs;
379
380   if (! have_ptrace_getfpxregs)
381     return 0;
382
383   if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
384     {
385       if (errno == EIO)
386         {
387           have_ptrace_getfpxregs = 0;
388           return 0;
389         }
390
391       perror_with_name (_("Couldn't read floating-point and SSE registers"));
392     }
393
394   i387_supply_fxsave (regcache, -1, (const elf_fpxregset_t *) &fpxregs);
395   return 1;
396 }
397
398 /* Store all valid registers in GDB's register array covered by the
399    PTRACE_SETFPXREGS request into the process/thread specified by TID.
400    Return non-zero if successful, zero otherwise.  */
401
402 static int
403 store_fpxregs (const struct regcache *regcache, int tid, int regno)
404 {
405   elf_fpxregset_t fpxregs;
406
407   if (! have_ptrace_getfpxregs)
408     return 0;
409   
410   if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
411     {
412       if (errno == EIO)
413         {
414           have_ptrace_getfpxregs = 0;
415           return 0;
416         }
417
418       perror_with_name (_("Couldn't read floating-point and SSE registers"));
419     }
420
421   i387_collect_fxsave (regcache, regno, &fpxregs);
422
423   if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
424     perror_with_name (_("Couldn't write floating-point and SSE registers"));
425
426   return 1;
427 }
428
429 #else
430
431 static int
432 fetch_fpxregs (struct regcache *regcache, int tid)
433 {
434   return 0;
435 }
436
437 static int
438 store_fpxregs (const struct regcache *regcache, int tid, int regno)
439 {
440   return 0;
441 }
442
443 #endif /* HAVE_PTRACE_GETFPXREGS */
444 \f
445
446 /* Transferring arbitrary registers between GDB and inferior.  */
447
448 /* Fetch register REGNO from the child process.  If REGNO is -1, do
449    this for all registers (including the floating point and SSE
450    registers).  */
451
452 static void
453 i386_linux_fetch_inferior_registers (struct target_ops *ops,
454                                      struct regcache *regcache, int regno)
455 {
456   int tid;
457
458   /* Use the old method of peeking around in `struct user' if the
459      GETREGS request isn't available.  */
460   if (!have_ptrace_getregs)
461     {
462       int i;
463
464       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
465         if (regno == -1 || regno == i)
466           fetch_register (regcache, i);
467
468       return;
469     }
470
471   /* GNU/Linux LWP ID's are process ID's.  */
472   tid = ptid_get_lwp (inferior_ptid);
473   if (tid == 0)
474     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
475
476   /* Use the PTRACE_GETFPXREGS request whenever possible, since it
477      transfers more registers in one system call, and we'll cache the
478      results.  But remember that fetch_fpxregs can fail, and return
479      zero.  */
480   if (regno == -1)
481     {
482       fetch_regs (regcache, tid);
483
484       /* The call above might reset `have_ptrace_getregs'.  */
485       if (!have_ptrace_getregs)
486         {
487           i386_linux_fetch_inferior_registers (ops, regcache, regno);
488           return;
489         }
490
491       if (fetch_xstateregs (regcache, tid))
492         return;
493       if (fetch_fpxregs (regcache, tid))
494         return;
495       fetch_fpregs (regcache, tid);
496       return;
497     }
498
499   if (GETREGS_SUPPLIES (regno))
500     {
501       fetch_regs (regcache, tid);
502       return;
503     }
504
505   if (GETXSTATEREGS_SUPPLIES (regno))
506     {
507       if (fetch_xstateregs (regcache, tid))
508         return;
509     }
510
511   if (GETFPXREGS_SUPPLIES (regno))
512     {
513       if (fetch_fpxregs (regcache, tid))
514         return;
515
516       /* Either our processor or our kernel doesn't support the SSE
517          registers, so read the FP registers in the traditional way,
518          and fill the SSE registers with dummy values.  It would be
519          more graceful to handle differences in the register set using
520          gdbarch.  Until then, this will at least make things work
521          plausibly.  */
522       fetch_fpregs (regcache, tid);
523       return;
524     }
525
526   internal_error (__FILE__, __LINE__,
527                   _("Got request for bad register number %d."), regno);
528 }
529
530 /* Store register REGNO back into the child process.  If REGNO is -1,
531    do this for all registers (including the floating point and SSE
532    registers).  */
533 static void
534 i386_linux_store_inferior_registers (struct target_ops *ops,
535                                      struct regcache *regcache, int regno)
536 {
537   int tid;
538
539   /* Use the old method of poking around in `struct user' if the
540      SETREGS request isn't available.  */
541   if (!have_ptrace_getregs)
542     {
543       int i;
544
545       for (i = 0; i < gdbarch_num_regs (get_regcache_arch (regcache)); i++)
546         if (regno == -1 || regno == i)
547           store_register (regcache, i);
548
549       return;
550     }
551
552   /* GNU/Linux LWP ID's are process ID's.  */
553   tid = ptid_get_lwp (inferior_ptid);
554   if (tid == 0)
555     tid = ptid_get_pid (inferior_ptid); /* Not a threaded program.  */
556
557   /* Use the PTRACE_SETFPXREGS requests whenever possible, since it
558      transfers more registers in one system call.  But remember that
559      store_fpxregs can fail, and return zero.  */
560   if (regno == -1)
561     {
562       store_regs (regcache, tid, regno);
563       if (store_xstateregs (regcache, tid, regno))
564         return;
565       if (store_fpxregs (regcache, tid, regno))
566         return;
567       store_fpregs (regcache, tid, regno);
568       return;
569     }
570
571   if (GETREGS_SUPPLIES (regno))
572     {
573       store_regs (regcache, tid, regno);
574       return;
575     }
576
577   if (GETXSTATEREGS_SUPPLIES (regno))
578     {
579       if (store_xstateregs (regcache, tid, regno))
580         return;
581     }
582
583   if (GETFPXREGS_SUPPLIES (regno))
584     {
585       if (store_fpxregs (regcache, tid, regno))
586         return;
587
588       /* Either our processor or our kernel doesn't support the SSE
589          registers, so just write the FP registers in the traditional
590          way.  */
591       store_fpregs (regcache, tid, regno);
592       return;
593     }
594
595   internal_error (__FILE__, __LINE__,
596                   _("Got request to store bad register number %d."), regno);
597 }
598 \f
599
600 /* Called by libthread_db.  Returns a pointer to the thread local
601    storage (or its descriptor).  */
602
603 ps_err_e
604 ps_get_thread_area (const struct ps_prochandle *ph,
605                     lwpid_t lwpid, int idx, void **base)
606 {
607   unsigned int base_addr;
608   ps_err_e result;
609
610   result = x86_linux_get_thread_area (lwpid, (void *) idx, &base_addr);
611
612   if (result == PS_OK)
613     *(int *) base = base_addr;
614
615   return result;
616 }
617 \f
618
619 /* The instruction for a GNU/Linux system call is:
620        int $0x80
621    or 0xcd 0x80.  */
622
623 static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
624
625 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
626
627 /* The system call number is stored in the %eax register.  */
628 #define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM
629
630 /* We are specifically interested in the sigreturn and rt_sigreturn
631    system calls.  */
632
633 #ifndef SYS_sigreturn
634 #define SYS_sigreturn           0x77
635 #endif
636 #ifndef SYS_rt_sigreturn
637 #define SYS_rt_sigreturn        0xad
638 #endif
639
640 /* Offset to saved processor flags, from <asm/sigcontext.h>.  */
641 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
642
643 /* Resume execution of the inferior process.
644    If STEP is nonzero, single-step it.
645    If SIGNAL is nonzero, give it that signal.  */
646
647 static void
648 i386_linux_resume (struct target_ops *ops,
649                    ptid_t ptid, int step, enum gdb_signal signal)
650 {
651   int pid = ptid_get_pid (ptid);
652
653   int request;
654
655   if (catch_syscall_enabled () > 0)
656    request = PTRACE_SYSCALL;
657   else
658     request = PTRACE_CONT;
659
660   if (step)
661     {
662       struct regcache *regcache = get_thread_regcache (pid_to_ptid (pid));
663       struct gdbarch *gdbarch = get_regcache_arch (regcache);
664       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
665       ULONGEST pc;
666       gdb_byte buf[LINUX_SYSCALL_LEN];
667
668       request = PTRACE_SINGLESTEP;
669
670       regcache_cooked_read_unsigned (regcache,
671                                      gdbarch_pc_regnum (gdbarch), &pc);
672
673       /* Returning from a signal trampoline is done by calling a
674          special system call (sigreturn or rt_sigreturn, see
675          i386-linux-tdep.c for more information).  This system call
676          restores the registers that were saved when the signal was
677          raised, including %eflags.  That means that single-stepping
678          won't work.  Instead, we'll have to modify the signal context
679          that's about to be restored, and set the trace flag there.  */
680
681       /* First check if PC is at a system call.  */
682       if (target_read_memory (pc, buf, LINUX_SYSCALL_LEN) == 0
683           && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
684         {
685           ULONGEST syscall;
686           regcache_cooked_read_unsigned (regcache,
687                                          LINUX_SYSCALL_REGNUM, &syscall);
688
689           /* Then check the system call number.  */
690           if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
691             {
692               ULONGEST sp, addr;
693               unsigned long int eflags;
694
695               regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp);
696               if (syscall == SYS_rt_sigreturn)
697                 addr = read_memory_unsigned_integer (sp + 8, 4, byte_order)
698                   + 20;
699               else
700                 addr = sp;
701
702               /* Set the trace flag in the context that's about to be
703                  restored.  */
704               addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
705               read_memory (addr, (gdb_byte *) &eflags, 4);
706               eflags |= 0x0100;
707               write_memory (addr, (gdb_byte *) &eflags, 4);
708             }
709         }
710     }
711
712   if (ptrace (request, pid, 0, gdb_signal_to_host (signal)) == -1)
713     perror_with_name (("ptrace"));
714 }
715 \f
716
717 /* -Wmissing-prototypes */
718 extern initialize_file_ftype _initialize_i386_linux_nat;
719
720 void
721 _initialize_i386_linux_nat (void)
722 {
723   /* Create a generic x86 GNU/Linux target.  */
724   struct target_ops *t = x86_linux_create_target ();
725
726   /* Override the default ptrace resume method.  */
727   t->to_resume = i386_linux_resume;
728
729   /* Add our register access methods.  */
730   t->to_fetch_registers = i386_linux_fetch_inferior_registers;
731   t->to_store_registers = i386_linux_store_inferior_registers;
732
733   /* Add the target.  */
734   x86_linux_add_target (t);
735 }