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 static struct linux_record_tdep i386_linux_record_tdep;
 358
 359 /* i386_canonicalize_syscall maps from the native i386 Linux set
 360    of syscall ids into a canonical set of syscall ids used by
 361    process record (a mostly trivial mapping, since the canonical
 362    set was originally taken from the i386 set).  */
 363
 364 static enum gdb_syscall
 365 i386_canonicalize_syscall (int syscall)
 366 {
 367   enum { i386_syscall_max = 499 };
 368
 369   if (syscall <= i386_syscall_max)
 370     return syscall;
 371   else
 372     return -1;
 373 }
 374
 375 /* Parse the arguments of current system call instruction and record
 376    the values of the registers and memory that will be changed into
 377    "record_arch_list".  This instruction is "int 0x80" (Linux
 378    Kernel2.4) or "sysenter" (Linux Kernel 2.6).
 379
 380    Return -1 if something wrong.  */
 381
 382 static int
 383 i386_linux_intx80_sysenter_record (struct regcache *regcache)
 384 {
 385   int ret;
 386   LONGEST syscall_native;
 387   enum gdb_syscall syscall_gdb;
 388
 389   regcache_raw_read_signed (regcache, I386_EAX_REGNUM, &syscall_native);
 390
 391   syscall_gdb = i386_canonicalize_syscall (syscall_native);
 392
 393   if (syscall_gdb < 0)
 394     {
 395       printf_unfiltered (_("Process record and replay target doesn't "
 396                            "support syscall number %s\n"),
 397                          plongest (syscall_native));
 398       return -1;
 399     }
 400
 401   ret = record_linux_system_call (syscall_gdb, regcache,
 402                                   &i386_linux_record_tdep);
 403   if (ret)
 404     return ret;
 405
 406   /* Record the return value of the system call.  */
 407   if (record_arch_list_add_reg (regcache, I386_EAX_REGNUM))
 408     return -1;
 409
 410   return 0;
 411 }
 412 \f
 413
 414 /* The register sets used in GNU/Linux ELF core-dumps are identical to
 415    the register sets in `struct user' that are used for a.out
 416    core-dumps.  These are also used by ptrace(2).  The corresponding
 417    types are `elf_gregset_t' for the general-purpose registers (with
 418    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
 419    for the floating-point registers.
 420
 421    Those types used to be available under the names `gregset_t' and
 422    `fpregset_t' too, and GDB used those names in the past.  But those
 423    names are now used for the register sets used in the `mcontext_t'
 424    type, which have a different size and layout.  */
 425
 426 /* Mapping between the general-purpose registers in `struct user'
 427    format and GDB's register cache layout.  */
 428
 429 /* From <sys/reg.h>.  */
 430 static int i386_linux_gregset_reg_offset[] =
 431 {
 432   6 * 4,                        /* %eax */
 433   1 * 4,                        /* %ecx */
 434   2 * 4,                        /* %edx */
 435   0 * 4,                        /* %ebx */
 436   15 * 4,                       /* %esp */
 437   5 * 4,                        /* %ebp */
 438   3 * 4,                        /* %esi */
 439   4 * 4,                        /* %edi */
 440   12 * 4,                       /* %eip */
 441   14 * 4,                       /* %eflags */
 442   13 * 4,                       /* %cs */
 443   16 * 4,                       /* %ss */
 444   7 * 4,                        /* %ds */
 445   8 * 4,                        /* %es */
 446   9 * 4,                        /* %fs */
 447   10 * 4,                       /* %gs */
 448   -1, -1, -1, -1, -1, -1, -1, -1,
 449   -1, -1, -1, -1, -1, -1, -1, -1,
 450   -1, -1, -1, -1, -1, -1, -1, -1,
 451   -1,
 452   11 * 4                        /* "orig_eax" */
 453 };
 454
 455 /* Mapping between the general-purpose registers in `struct
 456    sigcontext' format and GDB's register cache layout.  */
 457
 458 /* From <asm/sigcontext.h>.  */
 459 static int i386_linux_sc_reg_offset[] =
 460 {
 461   11 * 4,                       /* %eax */
 462   10 * 4,                       /* %ecx */
 463   9 * 4,                        /* %edx */
 464   8 * 4,                        /* %ebx */
 465   7 * 4,                        /* %esp */
 466   6 * 4,                        /* %ebp */
 467   5 * 4,                        /* %esi */
 468   4 * 4,                        /* %edi */
 469   14 * 4,                       /* %eip */
 470   16 * 4,                       /* %eflags */
 471   15 * 4,                       /* %cs */
 472   18 * 4,                       /* %ss */
 473   3 * 4,                        /* %ds */
 474   2 * 4,                        /* %es */
 475   1 * 4,                        /* %fs */
 476   0 * 4                         /* %gs */
 477 };
 478
 479 static void
 480 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 481 {
 482   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 483
 484   /* GNU/Linux uses ELF.  */
 485   i386_elf_init_abi (info, gdbarch);
 486
 487   /* Since we have the extra "orig_eax" register on GNU/Linux, we have
 488      to adjust a few things.  */
 489
 490   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 491   set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS);
 492   set_gdbarch_register_name (gdbarch, i386_linux_register_name);
 493   set_gdbarch_register_reggroup_p (gdbarch, i386_linux_register_reggroup_p);
 494
 495   tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
 496   tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
 497   tdep->sizeof_gregset = 17 * 4;
 498
 499   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 500
 501   tdep->sigtramp_p = i386_linux_sigtramp_p;
 502   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 503   tdep->sc_reg_offset = i386_linux_sc_reg_offset;
 504   tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset);
 505
 506   set_gdbarch_process_record (gdbarch, i386_process_record);
 507
 508   /* Initialize the i386_linux_record_tdep.  */
 509   /* These values are the size of the type that will be used in a system
 510      call.  They are obtained from Linux Kernel source.  */
 511   i386_linux_record_tdep.size_pointer
 512     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
 513   i386_linux_record_tdep.size__old_kernel_stat = 32;
 514   i386_linux_record_tdep.size_tms = 16;
 515   i386_linux_record_tdep.size_loff_t = 8;
 516   i386_linux_record_tdep.size_flock = 16;
 517   i386_linux_record_tdep.size_oldold_utsname = 45;
 518   i386_linux_record_tdep.size_ustat = 20;
 519   i386_linux_record_tdep.size_old_sigaction = 140;
 520   i386_linux_record_tdep.size_old_sigset_t = 128;
 521   i386_linux_record_tdep.size_rlimit = 8;
 522   i386_linux_record_tdep.size_rusage = 72;
 523   i386_linux_record_tdep.size_timeval = 8;
 524   i386_linux_record_tdep.size_timezone = 8;
 525   i386_linux_record_tdep.size_old_gid_t = 2;
 526   i386_linux_record_tdep.size_old_uid_t = 2;
 527   i386_linux_record_tdep.size_fd_set = 128;
 528   i386_linux_record_tdep.size_dirent = 268;
 529   i386_linux_record_tdep.size_dirent64 = 276;
 530   i386_linux_record_tdep.size_statfs = 64;
 531   i386_linux_record_tdep.size_statfs64 = 84;
 532   i386_linux_record_tdep.size_sockaddr = 16;
 533   i386_linux_record_tdep.size_int
 534     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
 535   i386_linux_record_tdep.size_long
 536     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
 537   i386_linux_record_tdep.size_ulong
 538     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
 539   i386_linux_record_tdep.size_msghdr = 28;
 540   i386_linux_record_tdep.size_itimerval = 16;
 541   i386_linux_record_tdep.size_stat = 88;
 542   i386_linux_record_tdep.size_old_utsname = 325;
 543   i386_linux_record_tdep.size_sysinfo = 64;
 544   i386_linux_record_tdep.size_msqid_ds = 88;
 545   i386_linux_record_tdep.size_shmid_ds = 84;
 546   i386_linux_record_tdep.size_new_utsname = 390;
 547   i386_linux_record_tdep.size_timex = 128;
 548   i386_linux_record_tdep.size_mem_dqinfo = 24;
 549   i386_linux_record_tdep.size_if_dqblk = 68;
 550   i386_linux_record_tdep.size_fs_quota_stat = 68;
 551   i386_linux_record_tdep.size_timespec = 8;
 552   i386_linux_record_tdep.size_pollfd = 8;
 553   i386_linux_record_tdep.size_NFS_FHSIZE = 32;
 554   i386_linux_record_tdep.size_knfsd_fh = 132;
 555   i386_linux_record_tdep.size_TASK_COMM_LEN = 16;
 556   i386_linux_record_tdep.size_sigaction = 140;
 557   i386_linux_record_tdep.size_sigset_t = 8;
 558   i386_linux_record_tdep.size_siginfo_t = 128;
 559   i386_linux_record_tdep.size_cap_user_data_t = 12;
 560   i386_linux_record_tdep.size_stack_t = 12;
 561   i386_linux_record_tdep.size_off_t = i386_linux_record_tdep.size_long;
 562   i386_linux_record_tdep.size_stat64 = 96;
 563   i386_linux_record_tdep.size_gid_t = 2;
 564   i386_linux_record_tdep.size_uid_t = 2;
 565   i386_linux_record_tdep.size_PAGE_SIZE = 4096;
 566   i386_linux_record_tdep.size_flock64 = 24;
 567   i386_linux_record_tdep.size_user_desc = 16;
 568   i386_linux_record_tdep.size_io_event = 32;
 569   i386_linux_record_tdep.size_iocb = 64;
 570   i386_linux_record_tdep.size_epoll_event = 12;
 571   i386_linux_record_tdep.size_itimerspec
 572     = i386_linux_record_tdep.size_timespec * 2;
 573   i386_linux_record_tdep.size_mq_attr = 32;
 574   i386_linux_record_tdep.size_siginfo = 128;
 575   i386_linux_record_tdep.size_termios = 36;
 576   i386_linux_record_tdep.size_termios2 = 44;
 577   i386_linux_record_tdep.size_pid_t = 4;
 578   i386_linux_record_tdep.size_winsize = 8;
 579   i386_linux_record_tdep.size_serial_struct = 60;
 580   i386_linux_record_tdep.size_serial_icounter_struct = 80;
 581   i386_linux_record_tdep.size_hayes_esp_config = 12;
 582   i386_linux_record_tdep.size_size_t = 4;
 583   i386_linux_record_tdep.size_iovec = 8;
 584
 585   /* These values are the second argument of system call "sys_ioctl".
 586      They are obtained from Linux Kernel source.  */
 587   i386_linux_record_tdep.ioctl_TCGETS = 0x5401;
 588   i386_linux_record_tdep.ioctl_TCSETS = 0x5402;
 589   i386_linux_record_tdep.ioctl_TCSETSW = 0x5403;
 590   i386_linux_record_tdep.ioctl_TCSETSF = 0x5404;
 591   i386_linux_record_tdep.ioctl_TCGETA = 0x5405;
 592   i386_linux_record_tdep.ioctl_TCSETA = 0x5406;
 593   i386_linux_record_tdep.ioctl_TCSETAW = 0x5407;
 594   i386_linux_record_tdep.ioctl_TCSETAF = 0x5408;
 595   i386_linux_record_tdep.ioctl_TCSBRK = 0x5409;
 596   i386_linux_record_tdep.ioctl_TCXONC = 0x540A;
 597   i386_linux_record_tdep.ioctl_TCFLSH = 0x540B;
 598   i386_linux_record_tdep.ioctl_TIOCEXCL = 0x540C;
 599   i386_linux_record_tdep.ioctl_TIOCNXCL = 0x540D;
 600   i386_linux_record_tdep.ioctl_TIOCSCTTY = 0x540E;
 601   i386_linux_record_tdep.ioctl_TIOCGPGRP = 0x540F;
 602   i386_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
 603   i386_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
 604   i386_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
 605   i386_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
 606   i386_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
 607   i386_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
 608   i386_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
 609   i386_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
 610   i386_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
 611   i386_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
 612   i386_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541A;
 613   i386_linux_record_tdep.ioctl_FIONREAD = 0x541B;
 614   i386_linux_record_tdep.ioctl_TIOCINQ = i386_linux_record_tdep.ioctl_FIONREAD;
 615   i386_linux_record_tdep.ioctl_TIOCLINUX = 0x541C;
 616   i386_linux_record_tdep.ioctl_TIOCCONS = 0x541D;
 617   i386_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541E;
 618   i386_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541F;
 619   i386_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
 620   i386_linux_record_tdep.ioctl_FIONBIO = 0x5421;
 621   i386_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
 622   i386_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
 623   i386_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
 624   i386_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
 625   i386_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
 626   i386_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
 627   i386_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
 628   i386_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
 629   i386_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
 630   i386_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
 631   i386_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
 632   i386_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
 633   i386_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
 634   i386_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
 635   i386_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
 636   i386_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
 637   i386_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
 638   i386_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
 639   i386_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
 640   i386_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
 641   i386_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
 642   i386_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
 643   i386_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
 644   i386_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
 645   i386_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545A;
 646   i386_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545B;
 647   i386_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545C;
 648   i386_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545D;
 649   i386_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545E;
 650   i386_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545F;
 651   i386_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
 652
 653   /* These values are the second argument of system call "sys_fcntl"
 654      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
 655   i386_linux_record_tdep.fcntl_F_GETLK = 5;
 656   i386_linux_record_tdep.fcntl_F_GETLK64 = 12;
 657   i386_linux_record_tdep.fcntl_F_SETLK64 = 13;
 658   i386_linux_record_tdep.fcntl_F_SETLKW64 = 14;
 659
 660   i386_linux_record_tdep.arg1 = I386_EBX_REGNUM;
 661   i386_linux_record_tdep.arg2 = I386_ECX_REGNUM;
 662   i386_linux_record_tdep.arg3 = I386_EDX_REGNUM;
 663   i386_linux_record_tdep.arg4 = I386_ESI_REGNUM;
 664   i386_linux_record_tdep.arg5 = I386_EDI_REGNUM;
 665   i386_linux_record_tdep.arg6 = I386_EBP_REGNUM;
 666
 667   tdep->i386_intx80_record = i386_linux_intx80_sysenter_record;
 668   tdep->i386_sysenter_record = i386_linux_intx80_sysenter_record;
 669
 670   /* N_FUN symbols in shared libaries have 0 for their values and need
 671      to be relocated. */
 672   set_gdbarch_sofun_address_maybe_missing (gdbarch, 1);
 673
 674   /* GNU/Linux uses SVR4-style shared libraries.  */
 675   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 676   set_solib_svr4_fetch_link_map_offsets
 677     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 678
 679   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
 680   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 681
 682   dwarf2_frame_set_signal_frame_p (gdbarch, i386_linux_dwarf_signal_frame_p);
 683
 684   /* Enable TLS support.  */
 685   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 686                                              svr4_fetch_objfile_link_map);
 687
 688   /* Install supported register note sections.  */
 689   set_gdbarch_core_regset_sections (gdbarch, i386_linux_regset_sections);
 690
 691   /* Displaced stepping.  */
 692   set_gdbarch_displaced_step_copy_insn (gdbarch,
 693                                         simple_displaced_step_copy_insn);
 694   set_gdbarch_displaced_step_fixup (gdbarch, i386_displaced_step_fixup);
 695   set_gdbarch_displaced_step_free_closure (gdbarch,
 696                                            simple_displaced_step_free_closure);
 697   set_gdbarch_displaced_step_location (gdbarch,
 698                                        displaced_step_at_entry_point);
 699
 700   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
 701 }
 702
 703 /* Provide a prototype to silence -Wmissing-prototypes.  */
 704 extern void _initialize_i386_linux_tdep (void);
 705
 706 void
 707 _initialize_i386_linux_tdep (void)
 708 {
 709   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
 710                           i386_linux_init_abi);
 711 }