gdb/i386-linux-tdep.c

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