gdb/i386-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux i386.
   2
   3    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "gdbcore.h"
  23 #include "frame.h"
  24 #include "value.h"
  25 #include "regcache.h"
  26 #include "inferior.h"
  27 #include "osabi.h"
  28 #include "reggroups.h"
  29 #include "dwarf2-frame.h"
  30 #include "gdb_string.h"
  31
  32 #include "i386-tdep.h"
  33 #include "i386-linux-tdep.h"
  34 #include "linux-tdep.h"
  35 #include "glibc-tdep.h"
  36 #include "solib-svr4.h"
  37 #include "symtab.h"
  38 #include "arch-utils.h"
  39 #include "regset.h"
  40 #include "xml-syscall.h"
  41
  42 /* The syscall's XML filename for i386.  */
  43 #define XML_SYSCALL_FILENAME_I386 "syscalls/i386-linux.xml"
  44
  45 #include "record.h"
  46 #include "linux-record.h"
  47 #include <stdint.h>
  48
  49 /* Supported register note sections.  */
  50 static struct core_regset_section i386_linux_regset_sections[] =
  51 {
  52   { ".reg", 144 },
  53   { ".reg2", 108 },
  54   { ".reg-xfp", 512 },
  55   { NULL, 0 }
  56 };
  57
  58 /* Return the name of register REG.  */
  59
  60 static const char *
  61 i386_linux_register_name (struct gdbarch *gdbarch, int reg)
  62 {
  63   /* Deal with the extra "orig_eax" pseudo register.  */
  64   if (reg == I386_LINUX_ORIG_EAX_REGNUM)
  65     return "orig_eax";
  66
  67   return i386_register_name (gdbarch, reg);
  68 }
  69
  70 /* Return non-zero, when the register is in the corresponding register
  71    group.  Put the LINUX_ORIG_EAX register in the system group.  */
  72 static int
  73 i386_linux_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
  74                                 struct reggroup *group)
  75 {
  76   if (regnum == I386_LINUX_ORIG_EAX_REGNUM)
  77     return (group == system_reggroup
  78             || group == save_reggroup
  79             || group == restore_reggroup);
  80   return i386_register_reggroup_p (gdbarch, regnum, group);
  81 }
  82
  83 \f
  84 /* Recognizing signal handler frames.  */
  85
  86 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  87    "realtime" (RT) signals.  The RT signals can provide additional
  88    information to the signal handler if the SA_SIGINFO flag is set
  89    when establishing a signal handler using `sigaction'.  It is not
  90    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  91    for normal signals too.  */
  92
  93 /* When the i386 Linux kernel calls a signal handler and the
  94    SA_RESTORER flag isn't set, the return address points to a bit of
  95    code on the stack.  This function returns whether the PC appears to
  96    be within this bit of code.
  97
  98    The instruction sequence for normal signals is
  99        pop    %eax
 100        mov    $0x77, %eax
 101        int    $0x80
 102    or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80.
 103
 104    Checking for the code sequence should be somewhat reliable, because
 105    the effect is to call the system call sigreturn.  This is unlikely
 106    to occur anywhere other than in a signal trampoline.
 107
 108    It kind of sucks that we have to read memory from the process in
 109    order to identify a signal trampoline, but there doesn't seem to be
 110    any other way.  Therefore we only do the memory reads if no
 111    function name could be identified, which should be the case since
 112    the code is on the stack.
 113
 114    Detection of signal trampolines for handlers that set the
 115    SA_RESTORER flag is in general not possible.  Unfortunately this is
 116    what the GNU C Library has been doing for quite some time now.
 117    However, as of version 2.1.2, the GNU C Library uses signal
 118    trampolines (named __restore and __restore_rt) that are identical
 119    to the ones used by the kernel.  Therefore, these trampolines are
 120    supported too.  */
 121
 122 #define LINUX_SIGTRAMP_INSN0    0x58    /* pop %eax */
 123 #define LINUX_SIGTRAMP_OFFSET0  0
 124 #define LINUX_SIGTRAMP_INSN1    0xb8    /* mov $NNNN, %eax */
 125 #define LINUX_SIGTRAMP_OFFSET1  1
 126 #define LINUX_SIGTRAMP_INSN2    0xcd    /* int */
 127 #define LINUX_SIGTRAMP_OFFSET2  6
 128
 129 static const gdb_byte linux_sigtramp_code[] =
 130 {
 131   LINUX_SIGTRAMP_INSN0,                                 /* pop %eax */
 132   LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00,         /* mov $0x77, %eax */
 133   LINUX_SIGTRAMP_INSN2, 0x80                            /* int $0x80 */
 134 };
 135
 136 #define LINUX_SIGTRAMP_LEN (sizeof linux_sigtramp_code)
 137
 138 /* If THIS_FRAME is a sigtramp routine, return the address of the
 139    start of the routine.  Otherwise, return 0.  */
 140
 141 static CORE_ADDR
 142 i386_linux_sigtramp_start (struct frame_info *this_frame)
 143 {
 144   CORE_ADDR pc = get_frame_pc (this_frame);
 145   gdb_byte buf[LINUX_SIGTRAMP_LEN];
 146
 147   /* We only recognize a signal trampoline if PC is at the start of
 148      one of the three instructions.  We optimize for finding the PC at
 149      the start, as will be the case when the trampoline is not the
 150      first frame on the stack.  We assume that in the case where the
 151      PC is not at the start of the instruction sequence, there will be
 152      a few trailing readable bytes on the stack.  */
 153
 154   if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN))
 155     return 0;
 156
 157   if (buf[0] != LINUX_SIGTRAMP_INSN0)
 158     {
 159       int adjust;
 160
 161       switch (buf[0])
 162         {
 163         case LINUX_SIGTRAMP_INSN1:
 164           adjust = LINUX_SIGTRAMP_OFFSET1;
 165           break;
 166         case LINUX_SIGTRAMP_INSN2:
 167           adjust = LINUX_SIGTRAMP_OFFSET2;
 168           break;
 169         default:
 170           return 0;
 171         }
 172
 173       pc -= adjust;
 174
 175       if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN))
 176         return 0;
 177     }
 178
 179   if (memcmp (buf, linux_sigtramp_code, LINUX_SIGTRAMP_LEN) != 0)
 180     return 0;
 181
 182   return pc;
 183 }
 184
 185 /* This function does the same for RT signals.  Here the instruction
 186    sequence is
 187        mov    $0xad, %eax
 188        int    $0x80
 189    or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80.
 190
 191    The effect is to call the system call rt_sigreturn.  */
 192
 193 #define LINUX_RT_SIGTRAMP_INSN0         0xb8 /* mov $NNNN, %eax */
 194 #define LINUX_RT_SIGTRAMP_OFFSET0       0
 195 #define LINUX_RT_SIGTRAMP_INSN1         0xcd /* int */
 196 #define LINUX_RT_SIGTRAMP_OFFSET1       5
 197
 198 static const gdb_byte linux_rt_sigtramp_code[] =
 199 {
 200   LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00,      /* mov $0xad, %eax */
 201   LINUX_RT_SIGTRAMP_INSN1, 0x80                         /* int $0x80 */
 202 };
 203
 204 #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code)
 205
 206 /* If THIS_FRAME is an RT sigtramp routine, return the address of the
 207    start of the routine.  Otherwise, return 0.  */
 208
 209 static CORE_ADDR
 210 i386_linux_rt_sigtramp_start (struct frame_info *this_frame)
 211 {
 212   CORE_ADDR pc = get_frame_pc (this_frame);
 213   gdb_byte buf[LINUX_RT_SIGTRAMP_LEN];
 214
 215   /* We only recognize a signal trampoline if PC is at the start of
 216      one of the two instructions.  We optimize for finding the PC at
 217      the start, as will be the case when the trampoline is not the
 218      first frame on the stack.  We assume that in the case where the
 219      PC is not at the start of the instruction sequence, there will be
 220      a few trailing readable bytes on the stack.  */
 221
 222   if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_RT_SIGTRAMP_LEN))
 223     return 0;
 224
 225   if (buf[0] != LINUX_RT_SIGTRAMP_INSN0)
 226     {
 227       if (buf[0] != LINUX_RT_SIGTRAMP_INSN1)
 228         return 0;
 229
 230       pc -= LINUX_RT_SIGTRAMP_OFFSET1;
 231
 232       if (!safe_frame_unwind_memory (this_frame, pc, buf,
 233                                      LINUX_RT_SIGTRAMP_LEN))
 234         return 0;
 235     }
 236
 237   if (memcmp (buf, linux_rt_sigtramp_code, LINUX_RT_SIGTRAMP_LEN) != 0)
 238     return 0;
 239
 240   return pc;
 241 }
 242
 243 /* Return whether THIS_FRAME corresponds to a GNU/Linux sigtramp
 244    routine.  */
 245
 246 static int
 247 i386_linux_sigtramp_p (struct frame_info *this_frame)
 248 {
 249   CORE_ADDR pc = get_frame_pc (this_frame);
 250   char *name;
 251
 252   find_pc_partial_function (pc, &name, NULL, NULL);
 253
 254   /* If we have NAME, we can optimize the search.  The trampolines are
 255      named __restore and __restore_rt.  However, they aren't dynamically
 256      exported from the shared C library, so the trampoline may appear to
 257      be part of the preceding function.  This should always be sigaction,
 258      __sigaction, or __libc_sigaction (all aliases to the same function).  */
 259   if (name == NULL || strstr (name, "sigaction") != NULL)
 260     return (i386_linux_sigtramp_start (this_frame) != 0
 261             || i386_linux_rt_sigtramp_start (this_frame) != 0);
 262
 263   return (strcmp ("__restore", name) == 0
 264           || strcmp ("__restore_rt", name) == 0);
 265 }
 266
 267 /* Return one if the PC of THIS_FRAME is in a signal trampoline which
 268    may have DWARF-2 CFI.  */
 269
 270 static int
 271 i386_linux_dwarf_signal_frame_p (struct gdbarch *gdbarch,
 272                                  struct frame_info *this_frame)
 273 {
 274   CORE_ADDR pc = get_frame_pc (this_frame);
 275   char *name;
 276
 277   find_pc_partial_function (pc, &name, NULL, NULL);
 278
 279   /* If a vsyscall DSO is in use, the signal trampolines may have these
 280      names.  */
 281   if (name && (strcmp (name, "__kernel_sigreturn") == 0
 282                || strcmp (name, "__kernel_rt_sigreturn") == 0))
 283     return 1;
 284
 285   return 0;
 286 }
 287
 288 /* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>.  */
 289 #define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20
 290
 291 /* Assuming THIS_FRAME is a GNU/Linux sigtramp routine, return the
 292    address of the associated sigcontext structure.  */
 293
 294 static CORE_ADDR
 295 i386_linux_sigcontext_addr (struct frame_info *this_frame)
 296 {
 297   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 298   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 299   CORE_ADDR pc;
 300   CORE_ADDR sp;
 301   gdb_byte buf[4];
 302
 303   get_frame_register (this_frame, I386_ESP_REGNUM, buf);
 304   sp = extract_unsigned_integer (buf, 4, byte_order);
 305
 306   pc = i386_linux_sigtramp_start (this_frame);
 307   if (pc)
 308     {
 309       /* The sigcontext structure lives on the stack, right after
 310          the signum argument.  We determine the address of the
 311          sigcontext structure by looking at the frame's stack
 312          pointer.  Keep in mind that the first instruction of the
 313          sigtramp code is "pop %eax".  If the PC is after this
 314          instruction, adjust the returned value accordingly.  */
 315       if (pc == get_frame_pc (this_frame))
 316         return sp + 4;
 317       return sp;
 318     }
 319
 320   pc = i386_linux_rt_sigtramp_start (this_frame);
 321   if (pc)
 322     {
 323       CORE_ADDR ucontext_addr;
 324
 325       /* The sigcontext structure is part of the user context.  A
 326          pointer to the user context is passed as the third argument
 327          to the signal handler.  */
 328       read_memory (sp + 8, buf, 4);
 329       ucontext_addr = extract_unsigned_integer (buf, 4, byte_order);
 330       return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET;
 331     }
 332
 333   error (_("Couldn't recognize signal trampoline."));
 334   return 0;
 335 }
 336
 337 /* Set the program counter for process PTID to PC.  */
 338
 339 static void
 340 i386_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 341 {
 342   regcache_cooked_write_unsigned (regcache, I386_EIP_REGNUM, pc);
 343
 344   /* We must be careful with modifying the program counter.  If we
 345      just interrupted a system call, the kernel might try to restart
 346      it when we resume the inferior.  On restarting the system call,
 347      the kernel will try backing up the program counter even though it
 348      no longer points at the system call.  This typically results in a
 349      SIGSEGV or SIGILL.  We can prevent this by writing `-1' in the
 350      "orig_eax" pseudo-register.
 351
 352      Note that "orig_eax" is saved when setting up a dummy call frame.
 353      This means that it is properly restored when that frame is
 354      popped, and that the interrupted system call will be restarted
 355      when we resume the inferior on return from a function call from
 356      within GDB.  In all other cases the system call will not be
 357      restarted.  */
 358   regcache_cooked_write_unsigned (regcache, I386_LINUX_ORIG_EAX_REGNUM, -1);
 359 }
 360
 361 static struct linux_record_tdep i386_linux_record_tdep;
 362
 363 /* i386_canonicalize_syscall maps from the native i386 Linux set
 364    of syscall ids into a canonical set of syscall ids used by
 365    process record (a mostly trivial mapping, since the canonical
 366    set was originally taken from the i386 set).  */
 367
 368 static enum gdb_syscall
 369 i386_canonicalize_syscall (int syscall)
 370 {
 371   enum { i386_syscall_max = 499 };
 372
 373   if (syscall <= i386_syscall_max)
 374     return syscall;
 375   else
 376     return -1;
 377 }
 378
 379 /* Parse the arguments of current system call instruction and record
 380    the values of the registers and memory that will be changed into
 381    "record_arch_list".  This instruction is "int 0x80" (Linux
 382    Kernel2.4) or "sysenter" (Linux Kernel 2.6).
 383
 384    Return -1 if something wrong.  */
 385
 386 static int
 387 i386_linux_intx80_sysenter_record (struct regcache *regcache)
 388 {
 389   int ret;
 390   LONGEST syscall_native;
 391   enum gdb_syscall syscall_gdb;
 392
 393   regcache_raw_read_signed (regcache, I386_EAX_REGNUM, &syscall_native);
 394
 395   syscall_gdb = i386_canonicalize_syscall (syscall_native);
 396
 397   if (syscall_gdb < 0)
 398     {
 399       printf_unfiltered (_("Process record and replay target doesn't "
 400                            "support syscall number %s\n"),
 401                          plongest (syscall_native));
 402       return -1;
 403     }
 404
 405   ret = record_linux_system_call (syscall_gdb, regcache,
 406                                   &i386_linux_record_tdep);
 407   if (ret)
 408     return ret;
 409
 410   /* Record the return value of the system call.  */
 411   if (record_arch_list_add_reg (regcache, I386_EAX_REGNUM))
 412     return -1;
 413
 414   return 0;
 415 }
 416 \f
 417
 418 static LONGEST
 419 i386_linux_get_syscall_number (struct gdbarch *gdbarch,
 420                                ptid_t ptid)
 421 {
 422   struct regcache *regcache = get_thread_regcache (ptid);
 423   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 424   /* The content of a register.  */
 425   gdb_byte buf[4];
 426   /* The result.  */
 427   LONGEST ret;
 428
 429   /* Getting the system call number from the register.
 430      When dealing with x86 architecture, this information
 431      is stored at %eax register.  */
 432   regcache_cooked_read (regcache, I386_LINUX_ORIG_EAX_REGNUM, buf);
 433
 434   ret = extract_signed_integer (buf, 4, byte_order);
 435
 436   return ret;
 437 }
 438
 439 /* The register sets used in GNU/Linux ELF core-dumps are identical to
 440    the register sets in `struct user' that are used for a.out
 441    core-dumps.  These are also used by ptrace(2).  The corresponding
 442    types are `elf_gregset_t' for the general-purpose registers (with
 443    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
 444    for the floating-point registers.
 445
 446    Those types used to be available under the names `gregset_t' and
 447    `fpregset_t' too, and GDB used those names in the past.  But those
 448    names are now used for the register sets used in the `mcontext_t'
 449    type, which have a different size and layout.  */
 450
 451 /* Mapping between the general-purpose registers in `struct user'
 452    format and GDB's register cache layout.  */
 453
 454 /* From <sys/reg.h>.  */
 455 static int i386_linux_gregset_reg_offset[] =
 456 {
 457   6 * 4,                        /* %eax */
 458   1 * 4,                        /* %ecx */
 459   2 * 4,                        /* %edx */
 460   0 * 4,                        /* %ebx */
 461   15 * 4,                       /* %esp */
 462   5 * 4,                        /* %ebp */
 463   3 * 4,                        /* %esi */
 464   4 * 4,                        /* %edi */
 465   12 * 4,                       /* %eip */
 466   14 * 4,                       /* %eflags */
 467   13 * 4,                       /* %cs */
 468   16 * 4,                       /* %ss */
 469   7 * 4,                        /* %ds */
 470   8 * 4,                        /* %es */
 471   9 * 4,                        /* %fs */
 472   10 * 4,                       /* %gs */
 473   -1, -1, -1, -1, -1, -1, -1, -1,
 474   -1, -1, -1, -1, -1, -1, -1, -1,
 475   -1, -1, -1, -1, -1, -1, -1, -1,
 476   -1,
 477   11 * 4                        /* "orig_eax" */
 478 };
 479
 480 /* Mapping between the general-purpose registers in `struct
 481    sigcontext' format and GDB's register cache layout.  */
 482
 483 /* From <asm/sigcontext.h>.  */
 484 static int i386_linux_sc_reg_offset[] =
 485 {
 486   11 * 4,                       /* %eax */
 487   10 * 4,                       /* %ecx */
 488   9 * 4,                        /* %edx */
 489   8 * 4,                        /* %ebx */
 490   7 * 4,                        /* %esp */
 491   6 * 4,                        /* %ebp */
 492   5 * 4,                        /* %esi */
 493   4 * 4,                        /* %edi */
 494   14 * 4,                       /* %eip */
 495   16 * 4,                       /* %eflags */
 496   15 * 4,                       /* %cs */
 497   18 * 4,                       /* %ss */
 498   3 * 4,                        /* %ds */
 499   2 * 4,                        /* %es */
 500   1 * 4,                        /* %fs */
 501   0 * 4                         /* %gs */
 502 };
 503
 504 static void
 505 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 506 {
 507   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 508
 509   /* GNU/Linux uses ELF.  */
 510   i386_elf_init_abi (info, gdbarch);
 511
 512   /* Since we have the extra "orig_eax" register on GNU/Linux, we have
 513      to adjust a few things.  */
 514
 515   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 516   set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS);
 517   set_gdbarch_register_name (gdbarch, i386_linux_register_name);
 518   set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p);
 519
 520   tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
 521   tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
 522   tdep->sizeof_gregset = 17 * 4;
 523
 524   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 525
 526   tdep->sigtramp_p = i386_linux_sigtramp_p;
 527   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 528   tdep->sc_reg_offset = i386_linux_sc_reg_offset;
 529   tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset);
 530
 531   set_gdbarch_process_record (gdbarch, i386_process_record);
 532
 533   /* Initialize the i386_linux_record_tdep.  */
 534   /* These values are the size of the type that will be used in a system
 535      call.  They are obtained from Linux Kernel source.  */
 536   i386_linux_record_tdep.size_pointer
 537     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
 538   i386_linux_record_tdep.size__old_kernel_stat = 32;
 539   i386_linux_record_tdep.size_tms = 16;
 540   i386_linux_record_tdep.size_loff_t = 8;
 541   i386_linux_record_tdep.size_flock = 16;
 542   i386_linux_record_tdep.size_oldold_utsname = 45;
 543   i386_linux_record_tdep.size_ustat = 20;
 544   i386_linux_record_tdep.size_old_sigaction = 140;
 545   i386_linux_record_tdep.size_old_sigset_t = 128;
 546   i386_linux_record_tdep.size_rlimit = 8;
 547   i386_linux_record_tdep.size_rusage = 72;
 548   i386_linux_record_tdep.size_timeval = 8;
 549   i386_linux_record_tdep.size_timezone = 8;
 550   i386_linux_record_tdep.size_old_gid_t = 2;
 551   i386_linux_record_tdep.size_old_uid_t = 2;
 552   i386_linux_record_tdep.size_fd_set = 128;
 553   i386_linux_record_tdep.size_dirent = 268;
 554   i386_linux_record_tdep.size_dirent64 = 276;
 555   i386_linux_record_tdep.size_statfs = 64;
 556   i386_linux_record_tdep.size_statfs64 = 84;
 557   i386_linux_record_tdep.size_sockaddr = 16;
 558   i386_linux_record_tdep.size_int
 559     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
 560   i386_linux_record_tdep.size_long
 561     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
 562   i386_linux_record_tdep.size_ulong
 563     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
 564   i386_linux_record_tdep.size_msghdr = 28;
 565   i386_linux_record_tdep.size_itimerval = 16;
 566   i386_linux_record_tdep.size_stat = 88;
 567   i386_linux_record_tdep.size_old_utsname = 325;
 568   i386_linux_record_tdep.size_sysinfo = 64;
 569   i386_linux_record_tdep.size_msqid_ds = 88;
 570   i386_linux_record_tdep.size_shmid_ds = 84;
 571   i386_linux_record_tdep.size_new_utsname = 390;
 572   i386_linux_record_tdep.size_timex = 128;
 573   i386_linux_record_tdep.size_mem_dqinfo = 24;
 574   i386_linux_record_tdep.size_if_dqblk = 68;
 575   i386_linux_record_tdep.size_fs_quota_stat = 68;
 576   i386_linux_record_tdep.size_timespec = 8;
 577   i386_linux_record_tdep.size_pollfd = 8;
 578   i386_linux_record_tdep.size_NFS_FHSIZE = 32;
 579   i386_linux_record_tdep.size_knfsd_fh = 132;
 580   i386_linux_record_tdep.size_TASK_COMM_LEN = 16;
 581   i386_linux_record_tdep.size_sigaction = 140;
 582   i386_linux_record_tdep.size_sigset_t = 8;
 583   i386_linux_record_tdep.size_siginfo_t = 128;
 584   i386_linux_record_tdep.size_cap_user_data_t = 12;
 585   i386_linux_record_tdep.size_stack_t = 12;
 586   i386_linux_record_tdep.size_off_t = i386_linux_record_tdep.size_long;
 587   i386_linux_record_tdep.size_stat64 = 96;
 588   i386_linux_record_tdep.size_gid_t = 2;
 589   i386_linux_record_tdep.size_uid_t = 2;
 590   i386_linux_record_tdep.size_PAGE_SIZE = 4096;
 591   i386_linux_record_tdep.size_flock64 = 24;
 592   i386_linux_record_tdep.size_user_desc = 16;
 593   i386_linux_record_tdep.size_io_event = 32;
 594   i386_linux_record_tdep.size_iocb = 64;
 595   i386_linux_record_tdep.size_epoll_event = 12;
 596   i386_linux_record_tdep.size_itimerspec
 597     = i386_linux_record_tdep.size_timespec * 2;
 598   i386_linux_record_tdep.size_mq_attr = 32;
 599   i386_linux_record_tdep.size_siginfo = 128;
 600   i386_linux_record_tdep.size_termios = 36;
 601   i386_linux_record_tdep.size_termios2 = 44;
 602   i386_linux_record_tdep.size_pid_t = 4;
 603   i386_linux_record_tdep.size_winsize = 8;
 604   i386_linux_record_tdep.size_serial_struct = 60;
 605   i386_linux_record_tdep.size_serial_icounter_struct = 80;
 606   i386_linux_record_tdep.size_hayes_esp_config = 12;
 607   i386_linux_record_tdep.size_size_t = 4;
 608   i386_linux_record_tdep.size_iovec = 8;
 609
 610   /* These values are the second argument of system call "sys_ioctl".
 611      They are obtained from Linux Kernel source.  */
 612   i386_linux_record_tdep.ioctl_TCGETS = 0x5401;
 613   i386_linux_record_tdep.ioctl_TCSETS = 0x5402;
 614   i386_linux_record_tdep.ioctl_TCSETSW = 0x5403;
 615   i386_linux_record_tdep.ioctl_TCSETSF = 0x5404;
 616   i386_linux_record_tdep.ioctl_TCGETA = 0x5405;
 617   i386_linux_record_tdep.ioctl_TCSETA = 0x5406;
 618   i386_linux_record_tdep.ioctl_TCSETAW = 0x5407;
 619   i386_linux_record_tdep.ioctl_TCSETAF = 0x5408;
 620   i386_linux_record_tdep.ioctl_TCSBRK = 0x5409;
 621   i386_linux_record_tdep.ioctl_TCXONC = 0x540A;
 622   i386_linux_record_tdep.ioctl_TCFLSH = 0x540B;
 623   i386_linux_record_tdep.ioctl_TIOCEXCL = 0x540C;
 624   i386_linux_record_tdep.ioctl_TIOCNXCL = 0x540D;
 625   i386_linux_record_tdep.ioctl_TIOCSCTTY = 0x540E;
 626   i386_linux_record_tdep.ioctl_TIOCGPGRP = 0x540F;
 627   i386_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
 628   i386_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
 629   i386_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
 630   i386_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
 631   i386_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
 632   i386_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
 633   i386_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
 634   i386_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
 635   i386_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
 636   i386_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
 637   i386_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541A;
 638   i386_linux_record_tdep.ioctl_FIONREAD = 0x541B;
 639   i386_linux_record_tdep.ioctl_TIOCINQ = i386_linux_record_tdep.ioctl_FIONREAD;
 640   i386_linux_record_tdep.ioctl_TIOCLINUX = 0x541C;
 641   i386_linux_record_tdep.ioctl_TIOCCONS = 0x541D;
 642   i386_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541E;
 643   i386_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541F;
 644   i386_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
 645   i386_linux_record_tdep.ioctl_FIONBIO = 0x5421;
 646   i386_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
 647   i386_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
 648   i386_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
 649   i386_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
 650   i386_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
 651   i386_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
 652   i386_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
 653   i386_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
 654   i386_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
 655   i386_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
 656   i386_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
 657   i386_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
 658   i386_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
 659   i386_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
 660   i386_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
 661   i386_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
 662   i386_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
 663   i386_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
 664   i386_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
 665   i386_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
 666   i386_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
 667   i386_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
 668   i386_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
 669   i386_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
 670   i386_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545A;
 671   i386_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545B;
 672   i386_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545C;
 673   i386_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545D;
 674   i386_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545E;
 675   i386_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545F;
 676   i386_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
 677
 678   /* These values are the second argument of system call "sys_fcntl"
 679      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
 680   i386_linux_record_tdep.fcntl_F_GETLK = 5;
 681   i386_linux_record_tdep.fcntl_F_GETLK64 = 12;
 682   i386_linux_record_tdep.fcntl_F_SETLK64 = 13;
 683   i386_linux_record_tdep.fcntl_F_SETLKW64 = 14;
 684
 685   i386_linux_record_tdep.arg1 = I386_EBX_REGNUM;
 686   i386_linux_record_tdep.arg2 = I386_ECX_REGNUM;
 687   i386_linux_record_tdep.arg3 = I386_EDX_REGNUM;
 688   i386_linux_record_tdep.arg4 = I386_ESI_REGNUM;
 689   i386_linux_record_tdep.arg5 = I386_EDI_REGNUM;
 690   i386_linux_record_tdep.arg6 = I386_EBP_REGNUM;
 691
 692   tdep->i386_intx80_record = i386_linux_intx80_sysenter_record;
 693   tdep->i386_sysenter_record = i386_linux_intx80_sysenter_record;
 694
 695   /* N_FUN symbols in shared libaries have 0 for their values and need
 696      to be relocated. */
 697   set_gdbarch_sofun_address_maybe_missing (gdbarch, 1);
 698
 699   /* GNU/Linux uses SVR4-style shared libraries.  */
 700   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 701   set_solib_svr4_fetch_link_map_offsets
 702     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 703
 704   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 705   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 706
 707   dwarf2_frame_set_signal_frame_p (gdbarch, i386_linux_dwarf_signal_frame_p);
 708
 709   /* Enable TLS support.  */
 710   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 711                                              svr4_fetch_objfile_link_map);
 712
 713   /* Install supported register note sections.  */
 714   set_gdbarch_core_regset_sections (gdbarch, i386_linux_regset_sections);
 715
 716   /* Displaced stepping.  */
 717   set_gdbarch_displaced_step_copy_insn (gdbarch,
 718                                         simple_displaced_step_copy_insn);
 719   set_gdbarch_displaced_step_fixup (gdbarch, i386_displaced_step_fixup);
 720   set_gdbarch_displaced_step_free_closure (gdbarch,
 721                                            simple_displaced_step_free_closure);
 722   set_gdbarch_displaced_step_location (gdbarch,
 723                                        displaced_step_at_entry_point);
 724
 725   /* Functions for 'catch syscall'.  */
 726   set_xml_syscall_file_name (XML_SYSCALL_FILENAME_I386);
 727   set_gdbarch_get_syscall_number (gdbarch,
 728                                   i386_linux_get_syscall_number);
 729
 730   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
 731 }
 732
 733 /* Provide a prototype to silence -Wmissing-prototypes.  */
 734 extern void _initialize_i386_linux_tdep (void);
 735
 736 void
 737 _initialize_i386_linux_tdep (void)
 738 {
 739   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
 740                           i386_linux_init_abi);
 741 }