gdb/i386-linux-tdep.c

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