gdb/i386-linux-tdep.c

   1 /* Target-dependent code for GNU/Linux i386.
   2
   3    Copyright (C) 2000-2019 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 "gdbcore.h"
  22 #include "frame.h"
  23 #include "value.h"
  24 #include "regcache.h"
  25 #include "regset.h"
  26 #include "inferior.h"
  27 #include "osabi.h"
  28 #include "reggroups.h"
  29 #include "dwarf2-frame.h"
  30 #include "i386-tdep.h"
  31 #include "i386-linux-tdep.h"
  32 #include "linux-tdep.h"
  33 #include "utils.h"
  34 #include "glibc-tdep.h"
  35 #include "solib-svr4.h"
  36 #include "symtab.h"
  37 #include "arch-utils.h"
  38 #include "xml-syscall.h"
  39
  40 #include "i387-tdep.h"
  41 #include "gdbsupport/x86-xstate.h"
  42
  43 /* The syscall's XML filename for i386.  */
  44 #define XML_SYSCALL_FILENAME_I386 "syscalls/i386-linux.xml"
  45
  46 #include "record-full.h"
  47 #include "linux-record.h"
  48
  49 #include "arch/i386.h"
  50 #include "target-descriptions.h"
  51
  52 /* Return non-zero, when the register is in the corresponding register
  53    group.  Put the LINUX_ORIG_EAX register in the system group.  */
  54 static int
  55 i386_linux_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
  56                                 struct reggroup *group)
  57 {
  58   if (regnum == I386_LINUX_ORIG_EAX_REGNUM)
  59     return (group == system_reggroup
  60             || group == save_reggroup
  61             || group == restore_reggroup);
  62   return i386_register_reggroup_p (gdbarch, regnum, group);
  63 }
  64
  65 \f
  66 /* Recognizing signal handler frames.  */
  67
  68 /* GNU/Linux has two flavors of signals.  Normal signal handlers, and
  69    "realtime" (RT) signals.  The RT signals can provide additional
  70    information to the signal handler if the SA_SIGINFO flag is set
  71    when establishing a signal handler using `sigaction'.  It is not
  72    unlikely that future versions of GNU/Linux will support SA_SIGINFO
  73    for normal signals too.  */
  74
  75 /* When the i386 Linux kernel calls a signal handler and the
  76    SA_RESTORER flag isn't set, the return address points to a bit of
  77    code on the stack.  This function returns whether the PC appears to
  78    be within this bit of code.
  79
  80    The instruction sequence for normal signals is
  81        pop    %eax
  82        mov    $0x77, %eax
  83        int    $0x80
  84    or 0x58 0xb8 0x77 0x00 0x00 0x00 0xcd 0x80.
  85
  86    Checking for the code sequence should be somewhat reliable, because
  87    the effect is to call the system call sigreturn.  This is unlikely
  88    to occur anywhere other than in a signal trampoline.
  89
  90    It kind of sucks that we have to read memory from the process in
  91    order to identify a signal trampoline, but there doesn't seem to be
  92    any other way.  Therefore we only do the memory reads if no
  93    function name could be identified, which should be the case since
  94    the code is on the stack.
  95
  96    Detection of signal trampolines for handlers that set the
  97    SA_RESTORER flag is in general not possible.  Unfortunately this is
  98    what the GNU C Library has been doing for quite some time now.
  99    However, as of version 2.1.2, the GNU C Library uses signal
 100    trampolines (named __restore and __restore_rt) that are identical
 101    to the ones used by the kernel.  Therefore, these trampolines are
 102    supported too.  */
 103
 104 #define LINUX_SIGTRAMP_INSN0    0x58    /* pop %eax */
 105 #define LINUX_SIGTRAMP_OFFSET0  0
 106 #define LINUX_SIGTRAMP_INSN1    0xb8    /* mov $NNNN, %eax */
 107 #define LINUX_SIGTRAMP_OFFSET1  1
 108 #define LINUX_SIGTRAMP_INSN2    0xcd    /* int */
 109 #define LINUX_SIGTRAMP_OFFSET2  6
 110
 111 static const gdb_byte linux_sigtramp_code[] =
 112 {
 113   LINUX_SIGTRAMP_INSN0,                                 /* pop %eax */
 114   LINUX_SIGTRAMP_INSN1, 0x77, 0x00, 0x00, 0x00,         /* mov $0x77, %eax */
 115   LINUX_SIGTRAMP_INSN2, 0x80                            /* int $0x80 */
 116 };
 117
 118 #define LINUX_SIGTRAMP_LEN (sizeof linux_sigtramp_code)
 119
 120 /* If THIS_FRAME is a sigtramp routine, return the address of the
 121    start of the routine.  Otherwise, return 0.  */
 122
 123 static CORE_ADDR
 124 i386_linux_sigtramp_start (struct frame_info *this_frame)
 125 {
 126   CORE_ADDR pc = get_frame_pc (this_frame);
 127   gdb_byte buf[LINUX_SIGTRAMP_LEN];
 128
 129   /* We only recognize a signal trampoline if PC is at the start of
 130      one of the three instructions.  We optimize for finding the PC at
 131      the start, as will be the case when the trampoline is not the
 132      first frame on the stack.  We assume that in the case where the
 133      PC is not at the start of the instruction sequence, there will be
 134      a few trailing readable bytes on the stack.  */
 135
 136   if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN))
 137     return 0;
 138
 139   if (buf[0] != LINUX_SIGTRAMP_INSN0)
 140     {
 141       int adjust;
 142
 143       switch (buf[0])
 144         {
 145         case LINUX_SIGTRAMP_INSN1:
 146           adjust = LINUX_SIGTRAMP_OFFSET1;
 147           break;
 148         case LINUX_SIGTRAMP_INSN2:
 149           adjust = LINUX_SIGTRAMP_OFFSET2;
 150           break;
 151         default:
 152           return 0;
 153         }
 154
 155       pc -= adjust;
 156
 157       if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_SIGTRAMP_LEN))
 158         return 0;
 159     }
 160
 161   if (memcmp (buf, linux_sigtramp_code, LINUX_SIGTRAMP_LEN) != 0)
 162     return 0;
 163
 164   return pc;
 165 }
 166
 167 /* This function does the same for RT signals.  Here the instruction
 168    sequence is
 169        mov    $0xad, %eax
 170        int    $0x80
 171    or 0xb8 0xad 0x00 0x00 0x00 0xcd 0x80.
 172
 173    The effect is to call the system call rt_sigreturn.  */
 174
 175 #define LINUX_RT_SIGTRAMP_INSN0         0xb8 /* mov $NNNN, %eax */
 176 #define LINUX_RT_SIGTRAMP_OFFSET0       0
 177 #define LINUX_RT_SIGTRAMP_INSN1         0xcd /* int */
 178 #define LINUX_RT_SIGTRAMP_OFFSET1       5
 179
 180 static const gdb_byte linux_rt_sigtramp_code[] =
 181 {
 182   LINUX_RT_SIGTRAMP_INSN0, 0xad, 0x00, 0x00, 0x00,      /* mov $0xad, %eax */
 183   LINUX_RT_SIGTRAMP_INSN1, 0x80                         /* int $0x80 */
 184 };
 185
 186 #define LINUX_RT_SIGTRAMP_LEN (sizeof linux_rt_sigtramp_code)
 187
 188 /* If THIS_FRAME is an RT sigtramp routine, return the address of the
 189    start of the routine.  Otherwise, return 0.  */
 190
 191 static CORE_ADDR
 192 i386_linux_rt_sigtramp_start (struct frame_info *this_frame)
 193 {
 194   CORE_ADDR pc = get_frame_pc (this_frame);
 195   gdb_byte buf[LINUX_RT_SIGTRAMP_LEN];
 196
 197   /* We only recognize a signal trampoline if PC is at the start of
 198      one of the two instructions.  We optimize for finding the PC at
 199      the start, as will be the case when the trampoline is not the
 200      first frame on the stack.  We assume that in the case where the
 201      PC is not at the start of the instruction sequence, there will be
 202      a few trailing readable bytes on the stack.  */
 203
 204   if (!safe_frame_unwind_memory (this_frame, pc, buf, LINUX_RT_SIGTRAMP_LEN))
 205     return 0;
 206
 207   if (buf[0] != LINUX_RT_SIGTRAMP_INSN0)
 208     {
 209       if (buf[0] != LINUX_RT_SIGTRAMP_INSN1)
 210         return 0;
 211
 212       pc -= LINUX_RT_SIGTRAMP_OFFSET1;
 213
 214       if (!safe_frame_unwind_memory (this_frame, pc, buf,
 215                                      LINUX_RT_SIGTRAMP_LEN))
 216         return 0;
 217     }
 218
 219   if (memcmp (buf, linux_rt_sigtramp_code, LINUX_RT_SIGTRAMP_LEN) != 0)
 220     return 0;
 221
 222   return pc;
 223 }
 224
 225 /* Return whether THIS_FRAME corresponds to a GNU/Linux sigtramp
 226    routine.  */
 227
 228 static int
 229 i386_linux_sigtramp_p (struct frame_info *this_frame)
 230 {
 231   CORE_ADDR pc = get_frame_pc (this_frame);
 232   const char *name;
 233
 234   find_pc_partial_function (pc, &name, NULL, NULL);
 235
 236   /* If we have NAME, we can optimize the search.  The trampolines are
 237      named __restore and __restore_rt.  However, they aren't dynamically
 238      exported from the shared C library, so the trampoline may appear to
 239      be part of the preceding function.  This should always be sigaction,
 240      __sigaction, or __libc_sigaction (all aliases to the same function).  */
 241   if (name == NULL || strstr (name, "sigaction") != NULL)
 242     return (i386_linux_sigtramp_start (this_frame) != 0
 243             || i386_linux_rt_sigtramp_start (this_frame) != 0);
 244
 245   return (strcmp ("__restore", name) == 0
 246           || strcmp ("__restore_rt", name) == 0);
 247 }
 248
 249 /* Return one if the PC of THIS_FRAME is in a signal trampoline which
 250    may have DWARF-2 CFI.  */
 251
 252 static int
 253 i386_linux_dwarf_signal_frame_p (struct gdbarch *gdbarch,
 254                                  struct frame_info *this_frame)
 255 {
 256   CORE_ADDR pc = get_frame_pc (this_frame);
 257   const char *name;
 258
 259   find_pc_partial_function (pc, &name, NULL, NULL);
 260
 261   /* If a vsyscall DSO is in use, the signal trampolines may have these
 262      names.  */
 263   if (name && (strcmp (name, "__kernel_sigreturn") == 0
 264                || strcmp (name, "__kernel_rt_sigreturn") == 0))
 265     return 1;
 266
 267   return 0;
 268 }
 269
 270 /* Offset to struct sigcontext in ucontext, from <asm/ucontext.h>.  */
 271 #define I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET 20
 272
 273 /* Assuming THIS_FRAME is a GNU/Linux sigtramp routine, return the
 274    address of the associated sigcontext structure.  */
 275
 276 static CORE_ADDR
 277 i386_linux_sigcontext_addr (struct frame_info *this_frame)
 278 {
 279   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 280   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 281   CORE_ADDR pc;
 282   CORE_ADDR sp;
 283   gdb_byte buf[4];
 284
 285   get_frame_register (this_frame, I386_ESP_REGNUM, buf);
 286   sp = extract_unsigned_integer (buf, 4, byte_order);
 287
 288   pc = i386_linux_sigtramp_start (this_frame);
 289   if (pc)
 290     {
 291       /* The sigcontext structure lives on the stack, right after
 292          the signum argument.  We determine the address of the
 293          sigcontext structure by looking at the frame's stack
 294          pointer.  Keep in mind that the first instruction of the
 295          sigtramp code is "pop %eax".  If the PC is after this
 296          instruction, adjust the returned value accordingly.  */
 297       if (pc == get_frame_pc (this_frame))
 298         return sp + 4;
 299       return sp;
 300     }
 301
 302   pc = i386_linux_rt_sigtramp_start (this_frame);
 303   if (pc)
 304     {
 305       CORE_ADDR ucontext_addr;
 306
 307       /* The sigcontext structure is part of the user context.  A
 308          pointer to the user context is passed as the third argument
 309          to the signal handler.  */
 310       read_memory (sp + 8, buf, 4);
 311       ucontext_addr = extract_unsigned_integer (buf, 4, byte_order);
 312       return ucontext_addr + I386_LINUX_UCONTEXT_SIGCONTEXT_OFFSET;
 313     }
 314
 315   error (_("Couldn't recognize signal trampoline."));
 316   return 0;
 317 }
 318
 319 /* Set the program counter for process PTID to PC.  */
 320
 321 static void
 322 i386_linux_write_pc (struct regcache *regcache, CORE_ADDR pc)
 323 {
 324   regcache_cooked_write_unsigned (regcache, I386_EIP_REGNUM, pc);
 325
 326   /* We must be careful with modifying the program counter.  If we
 327      just interrupted a system call, the kernel might try to restart
 328      it when we resume the inferior.  On restarting the system call,
 329      the kernel will try backing up the program counter even though it
 330      no longer points at the system call.  This typically results in a
 331      SIGSEGV or SIGILL.  We can prevent this by writing `-1' in the
 332      "orig_eax" pseudo-register.
 333
 334      Note that "orig_eax" is saved when setting up a dummy call frame.
 335      This means that it is properly restored when that frame is
 336      popped, and that the interrupted system call will be restarted
 337      when we resume the inferior on return from a function call from
 338      within GDB.  In all other cases the system call will not be
 339      restarted.  */
 340   regcache_cooked_write_unsigned (regcache, I386_LINUX_ORIG_EAX_REGNUM, -1);
 341 }
 342
 343 /* Record all registers but IP register for process-record.  */
 344
 345 static int
 346 i386_all_but_ip_registers_record (struct regcache *regcache)
 347 {
 348   if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM))
 349     return -1;
 350   if (record_full_arch_list_add_reg (regcache, I386_ECX_REGNUM))
 351     return -1;
 352   if (record_full_arch_list_add_reg (regcache, I386_EDX_REGNUM))
 353     return -1;
 354   if (record_full_arch_list_add_reg (regcache, I386_EBX_REGNUM))
 355     return -1;
 356   if (record_full_arch_list_add_reg (regcache, I386_ESP_REGNUM))
 357     return -1;
 358   if (record_full_arch_list_add_reg (regcache, I386_EBP_REGNUM))
 359     return -1;
 360   if (record_full_arch_list_add_reg (regcache, I386_ESI_REGNUM))
 361     return -1;
 362   if (record_full_arch_list_add_reg (regcache, I386_EDI_REGNUM))
 363     return -1;
 364   if (record_full_arch_list_add_reg (regcache, I386_EFLAGS_REGNUM))
 365     return -1;
 366
 367   return 0;
 368 }
 369
 370 /* i386_canonicalize_syscall maps from the native i386 Linux set
 371    of syscall ids into a canonical set of syscall ids used by
 372    process record (a mostly trivial mapping, since the canonical
 373    set was originally taken from the i386 set).  */
 374
 375 static enum gdb_syscall
 376 i386_canonicalize_syscall (int syscall)
 377 {
 378   enum { i386_syscall_max = 499 };
 379
 380   if (syscall <= i386_syscall_max)
 381     return (enum gdb_syscall) syscall;
 382   else
 383     return gdb_sys_no_syscall;
 384 }
 385
 386 /* Value of the sigcode in case of a boundary fault.  */
 387
 388 #define SIG_CODE_BONDARY_FAULT 3
 389
 390 /* i386 GNU/Linux implementation of the handle_segmentation_fault
 391    gdbarch hook.  Displays information related to MPX bound
 392    violations.  */
 393 void
 394 i386_linux_handle_segmentation_fault (struct gdbarch *gdbarch,
 395                                       struct ui_out *uiout)
 396 {
 397   /* -Wmaybe-uninitialized  */
 398   CORE_ADDR lower_bound = 0, upper_bound = 0, access = 0;
 399   int is_upper;
 400   long sig_code = 0;
 401
 402   if (!i386_mpx_enabled ())
 403     return;
 404
 405   try
 406     {
 407       /* Sigcode evaluates if the actual segfault is a boundary violation.  */
 408       sig_code = parse_and_eval_long ("$_siginfo.si_code\n");
 409
 410       lower_bound
 411         = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._lower");
 412       upper_bound
 413         = parse_and_eval_long ("$_siginfo._sifields._sigfault._addr_bnd._upper");
 414       access
 415         = parse_and_eval_long ("$_siginfo._sifields._sigfault.si_addr");
 416     }
 417   catch (const gdb_exception &exception)
 418     {
 419       return;
 420     }
 421
 422   /* If this is not a boundary violation just return.  */
 423   if (sig_code != SIG_CODE_BONDARY_FAULT)
 424     return;
 425
 426   is_upper = (access > upper_bound ? 1 : 0);
 427
 428   uiout->text ("\n");
 429   if (is_upper)
 430     uiout->field_string ("sigcode-meaning", _("Upper bound violation"));
 431   else
 432     uiout->field_string ("sigcode-meaning", _("Lower bound violation"));
 433
 434   uiout->text (_(" while accessing address "));
 435   uiout->field_core_addr ("bound-access", gdbarch, access);
 436
 437   uiout->text (_("\nBounds: [lower = "));
 438   uiout->field_core_addr ("lower-bound", gdbarch, lower_bound);
 439
 440   uiout->text (_(", upper = "));
 441   uiout->field_core_addr ("upper-bound", gdbarch, upper_bound);
 442
 443   uiout->text (_("]"));
 444 }
 445
 446 /* Parse the arguments of current system call instruction and record
 447    the values of the registers and memory that will be changed into
 448    "record_arch_list".  This instruction is "int 0x80" (Linux
 449    Kernel2.4) or "sysenter" (Linux Kernel 2.6).
 450
 451    Return -1 if something wrong.  */
 452
 453 static struct linux_record_tdep i386_linux_record_tdep;
 454
 455 static int
 456 i386_linux_intx80_sysenter_syscall_record (struct regcache *regcache)
 457 {
 458   int ret;
 459   LONGEST syscall_native;
 460   enum gdb_syscall syscall_gdb;
 461
 462   regcache_raw_read_signed (regcache, I386_EAX_REGNUM, &syscall_native);
 463
 464   syscall_gdb = i386_canonicalize_syscall (syscall_native);
 465
 466   if (syscall_gdb < 0)
 467     {
 468       printf_unfiltered (_("Process record and replay target doesn't "
 469                            "support syscall number %s\n"),
 470                          plongest (syscall_native));
 471       return -1;
 472     }
 473
 474   if (syscall_gdb == gdb_sys_sigreturn
 475       || syscall_gdb == gdb_sys_rt_sigreturn)
 476    {
 477      if (i386_all_but_ip_registers_record (regcache))
 478        return -1;
 479      return 0;
 480    }
 481
 482   ret = record_linux_system_call (syscall_gdb, regcache,
 483                                   &i386_linux_record_tdep);
 484   if (ret)
 485     return ret;
 486
 487   /* Record the return value of the system call.  */
 488   if (record_full_arch_list_add_reg (regcache, I386_EAX_REGNUM))
 489     return -1;
 490
 491   return 0;
 492 }
 493
 494 #define I386_LINUX_xstate       270
 495 #define I386_LINUX_frame_size   732
 496
 497 static int
 498 i386_linux_record_signal (struct gdbarch *gdbarch,
 499                           struct regcache *regcache,
 500                           enum gdb_signal signal)
 501 {
 502   ULONGEST esp;
 503
 504   if (i386_all_but_ip_registers_record (regcache))
 505     return -1;
 506
 507   if (record_full_arch_list_add_reg (regcache, I386_EIP_REGNUM))
 508     return -1;
 509
 510   /* Record the change in the stack.  */
 511   regcache_raw_read_unsigned (regcache, I386_ESP_REGNUM, &esp);
 512   /* This is for xstate.
 513      sp -= sizeof (struct _fpstate);  */
 514   esp -= I386_LINUX_xstate;
 515   /* This is for frame_size.
 516      sp -= sizeof (struct rt_sigframe);  */
 517   esp -= I386_LINUX_frame_size;
 518   if (record_full_arch_list_add_mem (esp,
 519                                      I386_LINUX_xstate + I386_LINUX_frame_size))
 520     return -1;
 521
 522   if (record_full_arch_list_add_end ())
 523     return -1;
 524
 525   return 0;
 526 }
 527 \f
 528
 529 /* Core of the implementation for gdbarch get_syscall_number.  Get pending
 530    syscall number from REGCACHE.  If there is no pending syscall -1 will be
 531    returned.  Pending syscall means ptrace has stepped into the syscall but
 532    another ptrace call will step out.  PC is right after the int $0x80
 533    / syscall / sysenter instruction in both cases, PC does not change during
 534    the second ptrace step.  */
 535
 536 static LONGEST
 537 i386_linux_get_syscall_number_from_regcache (struct regcache *regcache)
 538 {
 539   struct gdbarch *gdbarch = regcache->arch ();
 540   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 541   /* The content of a register.  */
 542   gdb_byte buf[4];
 543   /* The result.  */
 544   LONGEST ret;
 545
 546   /* Getting the system call number from the register.
 547      When dealing with x86 architecture, this information
 548      is stored at %eax register.  */
 549   regcache->cooked_read (I386_LINUX_ORIG_EAX_REGNUM, buf);
 550
 551   ret = extract_signed_integer (buf, 4, byte_order);
 552
 553   return ret;
 554 }
 555
 556 /* Wrapper for i386_linux_get_syscall_number_from_regcache to make it
 557    compatible with gdbarch get_syscall_number method prototype.  */
 558
 559 static LONGEST
 560 i386_linux_get_syscall_number (struct gdbarch *gdbarch,
 561                                thread_info *thread)
 562 {
 563   struct regcache *regcache = get_thread_regcache (thread);
 564
 565   return i386_linux_get_syscall_number_from_regcache (regcache);
 566 }
 567
 568 /* The register sets used in GNU/Linux ELF core-dumps are identical to
 569    the register sets in `struct user' that are used for a.out
 570    core-dumps.  These are also used by ptrace(2).  The corresponding
 571    types are `elf_gregset_t' for the general-purpose registers (with
 572    `elf_greg_t' the type of a single GP register) and `elf_fpregset_t'
 573    for the floating-point registers.
 574
 575    Those types used to be available under the names `gregset_t' and
 576    `fpregset_t' too, and GDB used those names in the past.  But those
 577    names are now used for the register sets used in the `mcontext_t'
 578    type, which have a different size and layout.  */
 579
 580 /* Mapping between the general-purpose registers in `struct user'
 581    format and GDB's register cache layout.  */
 582
 583 /* From <sys/reg.h>.  */
 584 int i386_linux_gregset_reg_offset[] =
 585 {
 586   6 * 4,                        /* %eax */
 587   1 * 4,                        /* %ecx */
 588   2 * 4,                        /* %edx */
 589   0 * 4,                        /* %ebx */
 590   15 * 4,                       /* %esp */
 591   5 * 4,                        /* %ebp */
 592   3 * 4,                        /* %esi */
 593   4 * 4,                        /* %edi */
 594   12 * 4,                       /* %eip */
 595   14 * 4,                       /* %eflags */
 596   13 * 4,                       /* %cs */
 597   16 * 4,                       /* %ss */
 598   7 * 4,                        /* %ds */
 599   8 * 4,                        /* %es */
 600   9 * 4,                        /* %fs */
 601   10 * 4,                       /* %gs */
 602   -1, -1, -1, -1, -1, -1, -1, -1,
 603   -1, -1, -1, -1, -1, -1, -1, -1,
 604   -1, -1, -1, -1, -1, -1, -1, -1,
 605   -1,
 606   -1, -1, -1, -1, -1, -1, -1, -1,
 607   -1, -1, -1, -1,                 /* MPX registers BND0 ... BND3.  */
 608   -1, -1,                         /* MPX registers BNDCFGU, BNDSTATUS.  */
 609   -1, -1, -1, -1, -1, -1, -1, -1, /* k0 ... k7 (AVX512)  */
 610   -1, -1, -1, -1, -1, -1, -1, -1, /* zmm0 ... zmm7 (AVX512)  */
 611   -1,                             /* PKRU register  */
 612   11 * 4,                         /* "orig_eax"  */
 613 };
 614
 615 /* Mapping between the general-purpose registers in `struct
 616    sigcontext' format and GDB's register cache layout.  */
 617
 618 /* From <asm/sigcontext.h>.  */
 619 static int i386_linux_sc_reg_offset[] =
 620 {
 621   11 * 4,                       /* %eax */
 622   10 * 4,                       /* %ecx */
 623   9 * 4,                        /* %edx */
 624   8 * 4,                        /* %ebx */
 625   7 * 4,                        /* %esp */
 626   6 * 4,                        /* %ebp */
 627   5 * 4,                        /* %esi */
 628   4 * 4,                        /* %edi */
 629   14 * 4,                       /* %eip */
 630   16 * 4,                       /* %eflags */
 631   15 * 4,                       /* %cs */
 632   18 * 4,                       /* %ss */
 633   3 * 4,                        /* %ds */
 634   2 * 4,                        /* %es */
 635   1 * 4,                        /* %fs */
 636   0 * 4                         /* %gs */
 637 };
 638
 639 /* Get XSAVE extended state xcr0 from core dump.  */
 640
 641 uint64_t
 642 i386_linux_core_read_xcr0 (bfd *abfd)
 643 {
 644   asection *xstate = bfd_get_section_by_name (abfd, ".reg-xstate");
 645   uint64_t xcr0;
 646
 647   if (xstate)
 648     {
 649       size_t size = bfd_section_size (abfd, xstate);
 650
 651       /* Check extended state size.  */
 652       if (size < X86_XSTATE_AVX_SIZE)
 653         xcr0 = X86_XSTATE_SSE_MASK;
 654       else
 655         {
 656           char contents[8];
 657
 658           if (! bfd_get_section_contents (abfd, xstate, contents,
 659                                           I386_LINUX_XSAVE_XCR0_OFFSET,
 660                                           8))
 661             {
 662               warning (_("Couldn't read `xcr0' bytes from "
 663                          "`.reg-xstate' section in core file."));
 664               return 0;
 665             }
 666
 667           xcr0 = bfd_get_64 (abfd, contents);
 668         }
 669     }
 670   else
 671     xcr0 = 0;
 672
 673   return xcr0;
 674 }
 675
 676 /* See i386-linux-tdep.h.  */
 677
 678 const struct target_desc *
 679 i386_linux_read_description (uint64_t xcr0)
 680 {
 681   if (xcr0 == 0)
 682     return NULL;
 683
 684   static struct target_desc *i386_linux_tdescs \
 685     [2/*X87*/][2/*SSE*/][2/*AVX*/][2/*MPX*/][2/*AVX512*/][2/*PKRU*/] = {};
 686   struct target_desc **tdesc;
 687
 688   tdesc = &i386_linux_tdescs[(xcr0 & X86_XSTATE_X87) ? 1 : 0]
 689     [(xcr0 & X86_XSTATE_SSE) ? 1 : 0]
 690     [(xcr0 & X86_XSTATE_AVX) ? 1 : 0]
 691     [(xcr0 & X86_XSTATE_MPX) ? 1 : 0]
 692     [(xcr0 & X86_XSTATE_AVX512) ? 1 : 0]
 693     [(xcr0 & X86_XSTATE_PKRU) ? 1 : 0];
 694
 695   if (*tdesc == NULL)
 696     *tdesc = i386_create_target_description (xcr0, true, false);
 697
 698   return *tdesc;
 699 }
 700
 701 /* Get Linux/x86 target description from core dump.  */
 702
 703 static const struct target_desc *
 704 i386_linux_core_read_description (struct gdbarch *gdbarch,
 705                                   struct target_ops *target,
 706                                   bfd *abfd)
 707 {
 708   /* Linux/i386.  */
 709   uint64_t xcr0 = i386_linux_core_read_xcr0 (abfd);
 710   const struct target_desc *tdesc = i386_linux_read_description (xcr0);
 711
 712   if (tdesc != NULL)
 713     return tdesc;
 714
 715   if (bfd_get_section_by_name (abfd, ".reg-xfp") != NULL)
 716     return i386_linux_read_description (X86_XSTATE_SSE_MASK);
 717   else
 718     return i386_linux_read_description (X86_XSTATE_X87_MASK);
 719 }
 720
 721 /* Similar to i386_supply_fpregset, but use XSAVE extended state.  */
 722
 723 static void
 724 i386_linux_supply_xstateregset (const struct regset *regset,
 725                                 struct regcache *regcache, int regnum,
 726                                 const void *xstateregs, size_t len)
 727 {
 728   i387_supply_xsave (regcache, regnum, xstateregs);
 729 }
 730
 731 struct type *
 732 x86_linux_get_siginfo_type (struct gdbarch *gdbarch)
 733 {
 734   return linux_get_siginfo_type_with_fields (gdbarch, LINUX_SIGINFO_FIELD_ADDR_BND);
 735 }
 736
 737 /* Similar to i386_collect_fpregset, but use XSAVE extended state.  */
 738
 739 static void
 740 i386_linux_collect_xstateregset (const struct regset *regset,
 741                                  const struct regcache *regcache,
 742                                  int regnum, void *xstateregs, size_t len)
 743 {
 744   i387_collect_xsave (regcache, regnum, xstateregs, 1);
 745 }
 746
 747 /* Register set definitions.  */
 748
 749 static const struct regset i386_linux_xstateregset =
 750   {
 751     NULL,
 752     i386_linux_supply_xstateregset,
 753     i386_linux_collect_xstateregset
 754   };
 755
 756 /* Iterate over core file register note sections.  */
 757
 758 static void
 759 i386_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 760                                          iterate_over_regset_sections_cb *cb,
 761                                          void *cb_data,
 762                                          const struct regcache *regcache)
 763 {
 764   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 765
 766   cb (".reg", 68, 68, &i386_gregset, NULL, cb_data);
 767
 768   if (tdep->xcr0 & X86_XSTATE_AVX)
 769     cb (".reg-xstate", X86_XSTATE_SIZE (tdep->xcr0),
 770         X86_XSTATE_SIZE (tdep->xcr0), &i386_linux_xstateregset,
 771         "XSAVE extended state", cb_data);
 772   else if (tdep->xcr0 & X86_XSTATE_SSE)
 773     cb (".reg-xfp", 512, 512, &i386_fpregset, "extended floating-point",
 774         cb_data);
 775   else
 776     cb (".reg2", 108, 108, &i386_fpregset, NULL, cb_data);
 777 }
 778
 779 /* Linux kernel shows PC value after the 'int $0x80' instruction even if
 780    inferior is still inside the syscall.  On next PTRACE_SINGLESTEP it will
 781    finish the syscall but PC will not change.
 782
 783    Some vDSOs contain 'int $0x80; ret' and during stepping out of the syscall
 784    i386_displaced_step_fixup would keep PC at the displaced pad location.
 785    As PC is pointing to the 'ret' instruction before the step
 786    i386_displaced_step_fixup would expect inferior has just executed that 'ret'
 787    and PC should not be adjusted.  In reality it finished syscall instead and
 788    PC should get relocated back to its vDSO address.  Hide the 'ret'
 789    instruction by 'nop' so that i386_displaced_step_fixup is not confused.
 790
 791    It is not fully correct as the bytes in struct displaced_step_closure will
 792    not match the inferior code.  But we would need some new flag in
 793    displaced_step_closure otherwise to keep the state that syscall is finishing
 794    for the later i386_displaced_step_fixup execution as the syscall execution
 795    is already no longer detectable there.  The new flag field would mean
 796    i386-linux-tdep.c needs to wrap all the displacement methods of i386-tdep.c
 797    which does not seem worth it.  The same effect is achieved by patching that
 798    'nop' instruction there instead.  */
 799
 800 static struct displaced_step_closure *
 801 i386_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
 802                                      CORE_ADDR from, CORE_ADDR to,
 803                                      struct regcache *regs)
 804 {
 805   displaced_step_closure *closure_
 806     =  i386_displaced_step_copy_insn (gdbarch, from, to, regs);
 807
 808   if (i386_linux_get_syscall_number_from_regcache (regs) != -1)
 809     {
 810       /* The closure returned by i386_displaced_step_copy_insn is simply a
 811          buffer with a copy of the instruction. */
 812       i386_displaced_step_closure *closure
 813         = (i386_displaced_step_closure *) closure_;
 814
 815       /* Fake nop.  */
 816       closure->buf[0] = 0x90;
 817     }
 818
 819   return closure_;
 820 }
 821
 822 static void
 823 i386_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 824 {
 825   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 826   const struct target_desc *tdesc = info.target_desc;
 827   struct tdesc_arch_data *tdesc_data = info.tdesc_data;
 828   const struct tdesc_feature *feature;
 829   int valid_p;
 830
 831   gdb_assert (tdesc_data);
 832
 833   linux_init_abi (info, gdbarch);
 834
 835   /* GNU/Linux uses ELF.  */
 836   i386_elf_init_abi (info, gdbarch);
 837
 838   /* Reserve a number for orig_eax.  */
 839   set_gdbarch_num_regs (gdbarch, I386_LINUX_NUM_REGS);
 840
 841   if (! tdesc_has_registers (tdesc))
 842     tdesc = i386_linux_read_description (X86_XSTATE_SSE_MASK);
 843   tdep->tdesc = tdesc;
 844
 845   feature = tdesc_find_feature (tdesc, "org.gnu.gdb.i386.linux");
 846   if (feature == NULL)
 847     return;
 848
 849   valid_p = tdesc_numbered_register (feature, tdesc_data,
 850                                      I386_LINUX_ORIG_EAX_REGNUM,
 851                                      "orig_eax");
 852   if (!valid_p)
 853     return;
 854
 855   /* Add the %orig_eax register used for syscall restarting.  */
 856   set_gdbarch_write_pc (gdbarch, i386_linux_write_pc);
 857
 858   tdep->register_reggroup_p = i386_linux_register_reggroup_p;
 859
 860   tdep->gregset_reg_offset = i386_linux_gregset_reg_offset;
 861   tdep->gregset_num_regs = ARRAY_SIZE (i386_linux_gregset_reg_offset);
 862   tdep->sizeof_gregset = 17 * 4;
 863
 864   tdep->jb_pc_offset = 20;      /* From <bits/setjmp.h>.  */
 865
 866   tdep->sigtramp_p = i386_linux_sigtramp_p;
 867   tdep->sigcontext_addr = i386_linux_sigcontext_addr;
 868   tdep->sc_reg_offset = i386_linux_sc_reg_offset;
 869   tdep->sc_num_regs = ARRAY_SIZE (i386_linux_sc_reg_offset);
 870
 871   tdep->xsave_xcr0_offset = I386_LINUX_XSAVE_XCR0_OFFSET;
 872
 873   set_gdbarch_process_record (gdbarch, i386_process_record);
 874   set_gdbarch_process_record_signal (gdbarch, i386_linux_record_signal);
 875
 876   /* Initialize the i386_linux_record_tdep.  */
 877   /* These values are the size of the type that will be used in a system
 878      call.  They are obtained from Linux Kernel source.  */
 879   i386_linux_record_tdep.size_pointer
 880     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
 881   i386_linux_record_tdep.size__old_kernel_stat = 32;
 882   i386_linux_record_tdep.size_tms = 16;
 883   i386_linux_record_tdep.size_loff_t = 8;
 884   i386_linux_record_tdep.size_flock = 16;
 885   i386_linux_record_tdep.size_oldold_utsname = 45;
 886   i386_linux_record_tdep.size_ustat = 20;
 887   i386_linux_record_tdep.size_old_sigaction = 16;
 888   i386_linux_record_tdep.size_old_sigset_t = 4;
 889   i386_linux_record_tdep.size_rlimit = 8;
 890   i386_linux_record_tdep.size_rusage = 72;
 891   i386_linux_record_tdep.size_timeval = 8;
 892   i386_linux_record_tdep.size_timezone = 8;
 893   i386_linux_record_tdep.size_old_gid_t = 2;
 894   i386_linux_record_tdep.size_old_uid_t = 2;
 895   i386_linux_record_tdep.size_fd_set = 128;
 896   i386_linux_record_tdep.size_old_dirent = 268;
 897   i386_linux_record_tdep.size_statfs = 64;
 898   i386_linux_record_tdep.size_statfs64 = 84;
 899   i386_linux_record_tdep.size_sockaddr = 16;
 900   i386_linux_record_tdep.size_int
 901     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
 902   i386_linux_record_tdep.size_long
 903     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
 904   i386_linux_record_tdep.size_ulong
 905     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
 906   i386_linux_record_tdep.size_msghdr = 28;
 907   i386_linux_record_tdep.size_itimerval = 16;
 908   i386_linux_record_tdep.size_stat = 88;
 909   i386_linux_record_tdep.size_old_utsname = 325;
 910   i386_linux_record_tdep.size_sysinfo = 64;
 911   i386_linux_record_tdep.size_msqid_ds = 88;
 912   i386_linux_record_tdep.size_shmid_ds = 84;
 913   i386_linux_record_tdep.size_new_utsname = 390;
 914   i386_linux_record_tdep.size_timex = 128;
 915   i386_linux_record_tdep.size_mem_dqinfo = 24;
 916   i386_linux_record_tdep.size_if_dqblk = 68;
 917   i386_linux_record_tdep.size_fs_quota_stat = 68;
 918   i386_linux_record_tdep.size_timespec = 8;
 919   i386_linux_record_tdep.size_pollfd = 8;
 920   i386_linux_record_tdep.size_NFS_FHSIZE = 32;
 921   i386_linux_record_tdep.size_knfsd_fh = 132;
 922   i386_linux_record_tdep.size_TASK_COMM_LEN = 16;
 923   i386_linux_record_tdep.size_sigaction = 20;
 924   i386_linux_record_tdep.size_sigset_t = 8;
 925   i386_linux_record_tdep.size_siginfo_t = 128;
 926   i386_linux_record_tdep.size_cap_user_data_t = 12;
 927   i386_linux_record_tdep.size_stack_t = 12;
 928   i386_linux_record_tdep.size_off_t = i386_linux_record_tdep.size_long;
 929   i386_linux_record_tdep.size_stat64 = 96;
 930   i386_linux_record_tdep.size_gid_t = 4;
 931   i386_linux_record_tdep.size_uid_t = 4;
 932   i386_linux_record_tdep.size_PAGE_SIZE = 4096;
 933   i386_linux_record_tdep.size_flock64 = 24;
 934   i386_linux_record_tdep.size_user_desc = 16;
 935   i386_linux_record_tdep.size_io_event = 32;
 936   i386_linux_record_tdep.size_iocb = 64;
 937   i386_linux_record_tdep.size_epoll_event = 12;
 938   i386_linux_record_tdep.size_itimerspec
 939     = i386_linux_record_tdep.size_timespec * 2;
 940   i386_linux_record_tdep.size_mq_attr = 32;
 941   i386_linux_record_tdep.size_termios = 36;
 942   i386_linux_record_tdep.size_termios2 = 44;
 943   i386_linux_record_tdep.size_pid_t = 4;
 944   i386_linux_record_tdep.size_winsize = 8;
 945   i386_linux_record_tdep.size_serial_struct = 60;
 946   i386_linux_record_tdep.size_serial_icounter_struct = 80;
 947   i386_linux_record_tdep.size_hayes_esp_config = 12;
 948   i386_linux_record_tdep.size_size_t = 4;
 949   i386_linux_record_tdep.size_iovec = 8;
 950   i386_linux_record_tdep.size_time_t = 4;
 951
 952   /* These values are the second argument of system call "sys_ioctl".
 953      They are obtained from Linux Kernel source.  */
 954   i386_linux_record_tdep.ioctl_TCGETS = 0x5401;
 955   i386_linux_record_tdep.ioctl_TCSETS = 0x5402;
 956   i386_linux_record_tdep.ioctl_TCSETSW = 0x5403;
 957   i386_linux_record_tdep.ioctl_TCSETSF = 0x5404;
 958   i386_linux_record_tdep.ioctl_TCGETA = 0x5405;
 959   i386_linux_record_tdep.ioctl_TCSETA = 0x5406;
 960   i386_linux_record_tdep.ioctl_TCSETAW = 0x5407;
 961   i386_linux_record_tdep.ioctl_TCSETAF = 0x5408;
 962   i386_linux_record_tdep.ioctl_TCSBRK = 0x5409;
 963   i386_linux_record_tdep.ioctl_TCXONC = 0x540A;
 964   i386_linux_record_tdep.ioctl_TCFLSH = 0x540B;
 965   i386_linux_record_tdep.ioctl_TIOCEXCL = 0x540C;
 966   i386_linux_record_tdep.ioctl_TIOCNXCL = 0x540D;
 967   i386_linux_record_tdep.ioctl_TIOCSCTTY = 0x540E;
 968   i386_linux_record_tdep.ioctl_TIOCGPGRP = 0x540F;
 969   i386_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
 970   i386_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
 971   i386_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
 972   i386_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
 973   i386_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
 974   i386_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
 975   i386_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
 976   i386_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
 977   i386_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
 978   i386_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
 979   i386_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541A;
 980   i386_linux_record_tdep.ioctl_FIONREAD = 0x541B;
 981   i386_linux_record_tdep.ioctl_TIOCINQ = i386_linux_record_tdep.ioctl_FIONREAD;
 982   i386_linux_record_tdep.ioctl_TIOCLINUX = 0x541C;
 983   i386_linux_record_tdep.ioctl_TIOCCONS = 0x541D;
 984   i386_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541E;
 985   i386_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541F;
 986   i386_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
 987   i386_linux_record_tdep.ioctl_FIONBIO = 0x5421;
 988   i386_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
 989   i386_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
 990   i386_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
 991   i386_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
 992   i386_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
 993   i386_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
 994   i386_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
 995   i386_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
 996   i386_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
 997   i386_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
 998   i386_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
 999   i386_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1000   i386_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1001   i386_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1002   i386_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1003   i386_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1004   i386_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1005   i386_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1006   i386_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1007   i386_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1008   i386_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1009   i386_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1010   i386_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1011   i386_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1012   i386_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545A;
1013   i386_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545B;
1014   i386_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545C;
1015   i386_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545D;
1016   i386_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545E;
1017   i386_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545F;
1018   i386_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1019
1020   /* These values are the second argument of system call "sys_fcntl"
1021      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1022   i386_linux_record_tdep.fcntl_F_GETLK = 5;
1023   i386_linux_record_tdep.fcntl_F_GETLK64 = 12;
1024   i386_linux_record_tdep.fcntl_F_SETLK64 = 13;
1025   i386_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1026
1027   i386_linux_record_tdep.arg1 = I386_EBX_REGNUM;
1028   i386_linux_record_tdep.arg2 = I386_ECX_REGNUM;
1029   i386_linux_record_tdep.arg3 = I386_EDX_REGNUM;
1030   i386_linux_record_tdep.arg4 = I386_ESI_REGNUM;
1031   i386_linux_record_tdep.arg5 = I386_EDI_REGNUM;
1032   i386_linux_record_tdep.arg6 = I386_EBP_REGNUM;
1033
1034   tdep->i386_intx80_record = i386_linux_intx80_sysenter_syscall_record;
1035   tdep->i386_sysenter_record = i386_linux_intx80_sysenter_syscall_record;
1036   tdep->i386_syscall_record = i386_linux_intx80_sysenter_syscall_record;
1037
1038   /* N_FUN symbols in shared libaries have 0 for their values and need
1039      to be relocated.  */
1040   set_gdbarch_sofun_address_maybe_missing (gdbarch, 1);
1041
1042   /* GNU/Linux uses SVR4-style shared libraries.  */
1043   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
1044   set_solib_svr4_fetch_link_map_offsets
1045     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
1046
1047   /* GNU/Linux uses the dynamic linker included in the GNU C Library.  */
1048   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1049
1050   dwarf2_frame_set_signal_frame_p (gdbarch, i386_linux_dwarf_signal_frame_p);
1051
1052   /* Enable TLS support.  */
1053   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1054                                              svr4_fetch_objfile_link_map);
1055
1056   /* Core file support.  */
1057   set_gdbarch_iterate_over_regset_sections
1058     (gdbarch, i386_linux_iterate_over_regset_sections);
1059   set_gdbarch_core_read_description (gdbarch,
1060                                      i386_linux_core_read_description);
1061
1062   /* Displaced stepping.  */
1063   set_gdbarch_displaced_step_copy_insn (gdbarch,
1064                                         i386_linux_displaced_step_copy_insn);
1065   set_gdbarch_displaced_step_fixup (gdbarch, i386_displaced_step_fixup);
1066   set_gdbarch_displaced_step_location (gdbarch,
1067                                        linux_displaced_step_location);
1068
1069   /* Functions for 'catch syscall'.  */
1070   set_xml_syscall_file_name (gdbarch, XML_SYSCALL_FILENAME_I386);
1071   set_gdbarch_get_syscall_number (gdbarch,
1072                                   i386_linux_get_syscall_number);
1073
1074   set_gdbarch_get_siginfo_type (gdbarch, x86_linux_get_siginfo_type);
1075   set_gdbarch_handle_segmentation_fault (gdbarch,
1076                                          i386_linux_handle_segmentation_fault);
1077 }
1078
1079 void
1080 _initialize_i386_linux_tdep (void)
1081 {
1082   gdbarch_register_osabi (bfd_arch_i386, 0, GDB_OSABI_LINUX,
1083                           i386_linux_init_abi);
1084 }