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