gdb/i386-linux-tdep.c

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