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