gdb/gdbserver/linux-x86-low.c

   1 /* GNU/Linux/x86-64 specific low level interface, for the remote server
   2    for GDB.
   3    Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include <stddef.h>
  22 #include <signal.h>
  23 #include "server.h"
  24 #include "linux-low.h"
  25 #include "i387-fp.h"
  26 #include "i386-low.h"
  27 #include "i386-xstate.h"
  28 #include "elf/common.h"
  29
  30 #include "gdb_proc_service.h"
  31
  32 /* Defined in auto-generated file i386-linux.c.  */
  33 void init_registers_i386_linux (void);
  34 /* Defined in auto-generated file amd64-linux.c.  */
  35 void init_registers_amd64_linux (void);
  36 /* Defined in auto-generated file i386-avx-linux.c.  */
  37 void init_registers_i386_avx_linux (void);
  38 /* Defined in auto-generated file amd64-avx-linux.c.  */
  39 void init_registers_amd64_avx_linux (void);
  40 /* Defined in auto-generated file i386-mmx-linux.c.  */
  41 void init_registers_i386_mmx_linux (void);
  42
  43 /* Backward compatibility for gdb without XML support.  */
  44
  45 static const char *xmltarget_i386_linux_no_xml = "@<target>\
  46 <architecture>i386</architecture>\
  47 <osabi>GNU/Linux</osabi>\
  48 </target>";
  49 static const char *xmltarget_amd64_linux_no_xml = "@<target>\
  50 <architecture>i386:x86-64</architecture>\
  51 <osabi>GNU/Linux</osabi>\
  52 </target>";
  53
  54 #include <sys/reg.h>
  55 #include <sys/procfs.h>
  56 #include <sys/ptrace.h>
  57 #include <sys/uio.h>
  58
  59 #ifndef PTRACE_GETREGSET
  60 #define PTRACE_GETREGSET        0x4204
  61 #endif
  62
  63 #ifndef PTRACE_SETREGSET
  64 #define PTRACE_SETREGSET        0x4205
  65 #endif
  66
  67
  68 #ifndef PTRACE_GET_THREAD_AREA
  69 #define PTRACE_GET_THREAD_AREA 25
  70 #endif
  71
  72 /* This definition comes from prctl.h, but some kernels may not have it.  */
  73 #ifndef PTRACE_ARCH_PRCTL
  74 #define PTRACE_ARCH_PRCTL      30
  75 #endif
  76
  77 /* The following definitions come from prctl.h, but may be absent
  78    for certain configurations.  */
  79 #ifndef ARCH_GET_FS
  80 #define ARCH_SET_GS 0x1001
  81 #define ARCH_SET_FS 0x1002
  82 #define ARCH_GET_FS 0x1003
  83 #define ARCH_GET_GS 0x1004
  84 #endif
  85
  86 /* Per-process arch-specific data we want to keep.  */
  87
  88 struct arch_process_info
  89 {
  90   struct i386_debug_reg_state debug_reg_state;
  91 };
  92
  93 /* Per-thread arch-specific data we want to keep.  */
  94
  95 struct arch_lwp_info
  96 {
  97   /* Non-zero if our copy differs from what's recorded in the thread.  */
  98   int debug_registers_changed;
  99 };
 100
 101 #ifdef __x86_64__
 102
 103 /* Mapping between the general-purpose registers in `struct user'
 104    format and GDB's register array layout.
 105    Note that the transfer layout uses 64-bit regs.  */
 106 static /*const*/ int i386_regmap[] =
 107 {
 108   RAX * 8, RCX * 8, RDX * 8, RBX * 8,
 109   RSP * 8, RBP * 8, RSI * 8, RDI * 8,
 110   RIP * 8, EFLAGS * 8, CS * 8, SS * 8,
 111   DS * 8, ES * 8, FS * 8, GS * 8
 112 };
 113
 114 #define I386_NUM_REGS (sizeof (i386_regmap) / sizeof (i386_regmap[0]))
 115
 116 /* So code below doesn't have to care, i386 or amd64.  */
 117 #define ORIG_EAX ORIG_RAX
 118
 119 static const int x86_64_regmap[] =
 120 {
 121   RAX * 8, RBX * 8, RCX * 8, RDX * 8,
 122   RSI * 8, RDI * 8, RBP * 8, RSP * 8,
 123   R8 * 8, R9 * 8, R10 * 8, R11 * 8,
 124   R12 * 8, R13 * 8, R14 * 8, R15 * 8,
 125   RIP * 8, EFLAGS * 8, CS * 8, SS * 8,
 126   DS * 8, ES * 8, FS * 8, GS * 8,
 127   -1, -1, -1, -1, -1, -1, -1, -1,
 128   -1, -1, -1, -1, -1, -1, -1, -1,
 129   -1, -1, -1, -1, -1, -1, -1, -1,
 130   -1, -1, -1, -1, -1, -1, -1, -1, -1,
 131   ORIG_RAX * 8
 132 };
 133
 134 #define X86_64_NUM_REGS (sizeof (x86_64_regmap) / sizeof (x86_64_regmap[0]))
 135
 136 #else /* ! __x86_64__ */
 137
 138 /* Mapping between the general-purpose registers in `struct user'
 139    format and GDB's register array layout.  */
 140 static /*const*/ int i386_regmap[] =
 141 {
 142   EAX * 4, ECX * 4, EDX * 4, EBX * 4,
 143   UESP * 4, EBP * 4, ESI * 4, EDI * 4,
 144   EIP * 4, EFL * 4, CS * 4, SS * 4,
 145   DS * 4, ES * 4, FS * 4, GS * 4
 146 };
 147
 148 #define I386_NUM_REGS (sizeof (i386_regmap) / sizeof (i386_regmap[0]))
 149
 150 #endif
 151 \f
 152 /* Called by libthread_db.  */
 153
 154 ps_err_e
 155 ps_get_thread_area (const struct ps_prochandle *ph,
 156                     lwpid_t lwpid, int idx, void **base)
 157 {
 158 #ifdef __x86_64__
 159   int use_64bit = register_size (0) == 8;
 160
 161   if (use_64bit)
 162     {
 163       switch (idx)
 164         {
 165         case FS:
 166           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0)
 167             return PS_OK;
 168           break;
 169         case GS:
 170           if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0)
 171             return PS_OK;
 172           break;
 173         default:
 174           return PS_BADADDR;
 175         }
 176       return PS_ERR;
 177     }
 178 #endif
 179
 180   {
 181     unsigned int desc[4];
 182
 183     if (ptrace (PTRACE_GET_THREAD_AREA, lwpid,
 184                 (void *) (intptr_t) idx, (unsigned long) &desc) < 0)
 185       return PS_ERR;
 186
 187     *(int *)base = desc[1];
 188     return PS_OK;
 189   }
 190 }
 191 \f
 192 static int
 193 i386_cannot_store_register (int regno)
 194 {
 195   return regno >= I386_NUM_REGS;
 196 }
 197
 198 static int
 199 i386_cannot_fetch_register (int regno)
 200 {
 201   return regno >= I386_NUM_REGS;
 202 }
 203
 204 static void
 205 x86_fill_gregset (struct regcache *regcache, void *buf)
 206 {
 207   int i;
 208
 209 #ifdef __x86_64__
 210   if (register_size (0) == 8)
 211     {
 212       for (i = 0; i < X86_64_NUM_REGS; i++)
 213         if (x86_64_regmap[i] != -1)
 214           collect_register (regcache, i, ((char *) buf) + x86_64_regmap[i]);
 215       return;
 216     }
 217 #endif
 218
 219   for (i = 0; i < I386_NUM_REGS; i++)
 220     collect_register (regcache, i, ((char *) buf) + i386_regmap[i]);
 221
 222   collect_register_by_name (regcache, "orig_eax",
 223                             ((char *) buf) + ORIG_EAX * 4);
 224 }
 225
 226 static void
 227 x86_store_gregset (struct regcache *regcache, const void *buf)
 228 {
 229   int i;
 230
 231 #ifdef __x86_64__
 232   if (register_size (0) == 8)
 233     {
 234       for (i = 0; i < X86_64_NUM_REGS; i++)
 235         if (x86_64_regmap[i] != -1)
 236           supply_register (regcache, i, ((char *) buf) + x86_64_regmap[i]);
 237       return;
 238     }
 239 #endif
 240
 241   for (i = 0; i < I386_NUM_REGS; i++)
 242     supply_register (regcache, i, ((char *) buf) + i386_regmap[i]);
 243
 244   supply_register_by_name (regcache, "orig_eax",
 245                            ((char *) buf) + ORIG_EAX * 4);
 246 }
 247
 248 static void
 249 x86_fill_fpregset (struct regcache *regcache, void *buf)
 250 {
 251 #ifdef __x86_64__
 252   i387_cache_to_fxsave (regcache, buf);
 253 #else
 254   i387_cache_to_fsave (regcache, buf);
 255 #endif
 256 }
 257
 258 static void
 259 x86_store_fpregset (struct regcache *regcache, const void *buf)
 260 {
 261 #ifdef __x86_64__
 262   i387_fxsave_to_cache (regcache, buf);
 263 #else
 264   i387_fsave_to_cache (regcache, buf);
 265 #endif
 266 }
 267
 268 #ifndef __x86_64__
 269
 270 static void
 271 x86_fill_fpxregset (struct regcache *regcache, void *buf)
 272 {
 273   i387_cache_to_fxsave (regcache, buf);
 274 }
 275
 276 static void
 277 x86_store_fpxregset (struct regcache *regcache, const void *buf)
 278 {
 279   i387_fxsave_to_cache (regcache, buf);
 280 }
 281
 282 #endif
 283
 284 static void
 285 x86_fill_xstateregset (struct regcache *regcache, void *buf)
 286 {
 287   i387_cache_to_xsave (regcache, buf);
 288 }
 289
 290 static void
 291 x86_store_xstateregset (struct regcache *regcache, const void *buf)
 292 {
 293   i387_xsave_to_cache (regcache, buf);
 294 }
 295
 296 /* ??? The non-biarch i386 case stores all the i387 regs twice.
 297    Once in i387_.*fsave.* and once in i387_.*fxsave.*.
 298    This is, presumably, to handle the case where PTRACE_[GS]ETFPXREGS
 299    doesn't work.  IWBN to avoid the duplication in the case where it
 300    does work.  Maybe the arch_setup routine could check whether it works
 301    and update target_regsets accordingly, maybe by moving target_regsets
 302    to linux_target_ops and set the right one there, rather than having to
 303    modify the target_regsets global.  */
 304
 305 struct regset_info target_regsets[] =
 306 {
 307 #ifdef HAVE_PTRACE_GETREGS
 308   { PTRACE_GETREGS, PTRACE_SETREGS, 0, sizeof (elf_gregset_t),
 309     GENERAL_REGS,
 310     x86_fill_gregset, x86_store_gregset },
 311   { PTRACE_GETREGSET, PTRACE_SETREGSET, NT_X86_XSTATE, 0,
 312     EXTENDED_REGS, x86_fill_xstateregset, x86_store_xstateregset },
 313 # ifndef __x86_64__
 314 #  ifdef HAVE_PTRACE_GETFPXREGS
 315   { PTRACE_GETFPXREGS, PTRACE_SETFPXREGS, 0, sizeof (elf_fpxregset_t),
 316     EXTENDED_REGS,
 317     x86_fill_fpxregset, x86_store_fpxregset },
 318 #  endif
 319 # endif
 320   { PTRACE_GETFPREGS, PTRACE_SETFPREGS, 0, sizeof (elf_fpregset_t),
 321     FP_REGS,
 322     x86_fill_fpregset, x86_store_fpregset },
 323 #endif /* HAVE_PTRACE_GETREGS */
 324   { 0, 0, 0, -1, -1, NULL, NULL }
 325 };
 326
 327 static CORE_ADDR
 328 x86_get_pc (struct regcache *regcache)
 329 {
 330   int use_64bit = register_size (0) == 8;
 331
 332   if (use_64bit)
 333     {
 334       unsigned long pc;
 335       collect_register_by_name (regcache, "rip", &pc);
 336       return (CORE_ADDR) pc;
 337     }
 338   else
 339     {
 340       unsigned int pc;
 341       collect_register_by_name (regcache, "eip", &pc);
 342       return (CORE_ADDR) pc;
 343     }
 344 }
 345
 346 static void
 347 x86_set_pc (struct regcache *regcache, CORE_ADDR pc)
 348 {
 349   int use_64bit = register_size (0) == 8;
 350
 351   if (use_64bit)
 352     {
 353       unsigned long newpc = pc;
 354       supply_register_by_name (regcache, "rip", &newpc);
 355     }
 356   else
 357     {
 358       unsigned int newpc = pc;
 359       supply_register_by_name (regcache, "eip", &newpc);
 360     }
 361 }
 362 \f
 363 static const unsigned char x86_breakpoint[] = { 0xCC };
 364 #define x86_breakpoint_len 1
 365
 366 static int
 367 x86_breakpoint_at (CORE_ADDR pc)
 368 {
 369   unsigned char c;
 370
 371   (*the_target->read_memory) (pc, &c, 1);
 372   if (c == 0xCC)
 373     return 1;
 374
 375   return 0;
 376 }
 377 \f
 378 /* Support for debug registers.  */
 379
 380 static unsigned long
 381 x86_linux_dr_get (ptid_t ptid, int regnum)
 382 {
 383   int tid;
 384   unsigned long value;
 385
 386   tid = ptid_get_lwp (ptid);
 387
 388   errno = 0;
 389   value = ptrace (PTRACE_PEEKUSER, tid,
 390                   offsetof (struct user, u_debugreg[regnum]), 0);
 391   if (errno != 0)
 392     error ("Couldn't read debug register");
 393
 394   return value;
 395 }
 396
 397 static void
 398 x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
 399 {
 400   int tid;
 401
 402   tid = ptid_get_lwp (ptid);
 403
 404   errno = 0;
 405   ptrace (PTRACE_POKEUSER, tid,
 406           offsetof (struct user, u_debugreg[regnum]), value);
 407   if (errno != 0)
 408     error ("Couldn't write debug register");
 409 }
 410
 411 /* Update the inferior's debug register REGNUM from STATE.  */
 412
 413 void
 414 i386_dr_low_set_addr (const struct i386_debug_reg_state *state, int regnum)
 415 {
 416   struct inferior_list_entry *lp;
 417   CORE_ADDR addr;
 418   /* Only need to update the threads of this process.  */
 419   int pid = pid_of (get_thread_lwp (current_inferior));
 420
 421   if (! (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR))
 422     fatal ("Invalid debug register %d", regnum);
 423
 424   addr = state->dr_mirror[regnum];
 425
 426   for (lp = all_lwps.head; lp; lp = lp->next)
 427     {
 428       struct lwp_info *lwp = (struct lwp_info *) lp;
 429
 430       /* The actual update is done later, we just mark that the register
 431          needs updating.  */
 432       if (pid_of (lwp) == pid)
 433         lwp->arch_private->debug_registers_changed = 1;
 434     }
 435 }
 436
 437 /* Update the inferior's DR7 debug control register from STATE.  */
 438
 439 void
 440 i386_dr_low_set_control (const struct i386_debug_reg_state *state)
 441 {
 442   struct inferior_list_entry *lp;
 443   /* Only need to update the threads of this process.  */
 444   int pid = pid_of (get_thread_lwp (current_inferior));
 445
 446   for (lp = all_lwps.head; lp; lp = lp->next)
 447     {
 448       struct lwp_info *lwp = (struct lwp_info *) lp;
 449
 450       /* The actual update is done later, we just mark that the register
 451          needs updating.  */
 452       if (pid_of (lwp) == pid)
 453         lwp->arch_private->debug_registers_changed = 1;
 454     }
 455 }
 456
 457 /* Get the value of the DR6 debug status register from the inferior
 458    and record it in STATE.  */
 459
 460 void
 461 i386_dr_low_get_status (struct i386_debug_reg_state *state)
 462 {
 463   struct lwp_info *lwp = get_thread_lwp (current_inferior);
 464   ptid_t ptid = ptid_of (lwp);
 465
 466   state->dr_status_mirror = x86_linux_dr_get (ptid, DR_STATUS);
 467 }
 468 \f
 469 /* Watchpoint support.  */
 470
 471 static int
 472 x86_insert_point (char type, CORE_ADDR addr, int len)
 473 {
 474   struct process_info *proc = current_process ();
 475   switch (type)
 476     {
 477     case '0':
 478       return set_gdb_breakpoint_at (addr);
 479     case '2':
 480     case '3':
 481     case '4':
 482       return i386_low_insert_watchpoint (&proc->private->arch_private->debug_reg_state,
 483                                          type, addr, len);
 484     default:
 485       /* Unsupported.  */
 486       return 1;
 487     }
 488 }
 489
 490 static int
 491 x86_remove_point (char type, CORE_ADDR addr, int len)
 492 {
 493   struct process_info *proc = current_process ();
 494   switch (type)
 495     {
 496     case '0':
 497       return delete_gdb_breakpoint_at (addr);
 498     case '2':
 499     case '3':
 500     case '4':
 501       return i386_low_remove_watchpoint (&proc->private->arch_private->debug_reg_state,
 502                                          type, addr, len);
 503     default:
 504       /* Unsupported.  */
 505       return 1;
 506     }
 507 }
 508
 509 static int
 510 x86_stopped_by_watchpoint (void)
 511 {
 512   struct process_info *proc = current_process ();
 513   return i386_low_stopped_by_watchpoint (&proc->private->arch_private->debug_reg_state);
 514 }
 515
 516 static CORE_ADDR
 517 x86_stopped_data_address (void)
 518 {
 519   struct process_info *proc = current_process ();
 520   CORE_ADDR addr;
 521   if (i386_low_stopped_data_address (&proc->private->arch_private->debug_reg_state,
 522                                      &addr))
 523     return addr;
 524   return 0;
 525 }
 526 \f
 527 /* Called when a new process is created.  */
 528
 529 static struct arch_process_info *
 530 x86_linux_new_process (void)
 531 {
 532   struct arch_process_info *info = xcalloc (1, sizeof (*info));
 533
 534   i386_low_init_dregs (&info->debug_reg_state);
 535
 536   return info;
 537 }
 538
 539 /* Called when a new thread is detected.  */
 540
 541 static struct arch_lwp_info *
 542 x86_linux_new_thread (void)
 543 {
 544   struct arch_lwp_info *info = xcalloc (1, sizeof (*info));
 545
 546   info->debug_registers_changed = 1;
 547
 548   return info;
 549 }
 550
 551 /* Called when resuming a thread.
 552    If the debug regs have changed, update the thread's copies.  */
 553
 554 static void
 555 x86_linux_prepare_to_resume (struct lwp_info *lwp)
 556 {
 557   ptid_t ptid = ptid_of (lwp);
 558
 559   if (lwp->arch_private->debug_registers_changed)
 560     {
 561       int i;
 562       int pid = ptid_get_pid (ptid);
 563       struct process_info *proc = find_process_pid (pid);
 564       struct i386_debug_reg_state *state = &proc->private->arch_private->debug_reg_state;
 565
 566       for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++)
 567         x86_linux_dr_set (ptid, i, state->dr_mirror[i]);
 568
 569       x86_linux_dr_set (ptid, DR_CONTROL, state->dr_control_mirror);
 570
 571       lwp->arch_private->debug_registers_changed = 0;
 572     }
 573
 574   if (lwp->stopped_by_watchpoint)
 575     x86_linux_dr_set (ptid, DR_STATUS, 0);
 576 }
 577 \f
 578 /* When GDBSERVER is built as a 64-bit application on linux, the
 579    PTRACE_GETSIGINFO data is always presented in 64-bit layout.  Since
 580    debugging a 32-bit inferior with a 64-bit GDBSERVER should look the same
 581    as debugging it with a 32-bit GDBSERVER, we do the 32-bit <-> 64-bit
 582    conversion in-place ourselves.  */
 583
 584 /* These types below (compat_*) define a siginfo type that is layout
 585    compatible with the siginfo type exported by the 32-bit userspace
 586    support.  */
 587
 588 #ifdef __x86_64__
 589
 590 typedef int compat_int_t;
 591 typedef unsigned int compat_uptr_t;
 592
 593 typedef int compat_time_t;
 594 typedef int compat_timer_t;
 595 typedef int compat_clock_t;
 596
 597 struct compat_timeval
 598 {
 599   compat_time_t tv_sec;
 600   int tv_usec;
 601 };
 602
 603 typedef union compat_sigval
 604 {
 605   compat_int_t sival_int;
 606   compat_uptr_t sival_ptr;
 607 } compat_sigval_t;
 608
 609 typedef struct compat_siginfo
 610 {
 611   int si_signo;
 612   int si_errno;
 613   int si_code;
 614
 615   union
 616   {
 617     int _pad[((128 / sizeof (int)) - 3)];
 618
 619     /* kill() */
 620     struct
 621     {
 622       unsigned int _pid;
 623       unsigned int _uid;
 624     } _kill;
 625
 626     /* POSIX.1b timers */
 627     struct
 628     {
 629       compat_timer_t _tid;
 630       int _overrun;
 631       compat_sigval_t _sigval;
 632     } _timer;
 633
 634     /* POSIX.1b signals */
 635     struct
 636     {
 637       unsigned int _pid;
 638       unsigned int _uid;
 639       compat_sigval_t _sigval;
 640     } _rt;
 641
 642     /* SIGCHLD */
 643     struct
 644     {
 645       unsigned int _pid;
 646       unsigned int _uid;
 647       int _status;
 648       compat_clock_t _utime;
 649       compat_clock_t _stime;
 650     } _sigchld;
 651
 652     /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */
 653     struct
 654     {
 655       unsigned int _addr;
 656     } _sigfault;
 657
 658     /* SIGPOLL */
 659     struct
 660     {
 661       int _band;
 662       int _fd;
 663     } _sigpoll;
 664   } _sifields;
 665 } compat_siginfo_t;
 666
 667 #define cpt_si_pid _sifields._kill._pid
 668 #define cpt_si_uid _sifields._kill._uid
 669 #define cpt_si_timerid _sifields._timer._tid
 670 #define cpt_si_overrun _sifields._timer._overrun
 671 #define cpt_si_status _sifields._sigchld._status
 672 #define cpt_si_utime _sifields._sigchld._utime
 673 #define cpt_si_stime _sifields._sigchld._stime
 674 #define cpt_si_ptr _sifields._rt._sigval.sival_ptr
 675 #define cpt_si_addr _sifields._sigfault._addr
 676 #define cpt_si_band _sifields._sigpoll._band
 677 #define cpt_si_fd _sifields._sigpoll._fd
 678
 679 /* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun.
 680    In their place is si_timer1,si_timer2.  */
 681 #ifndef si_timerid
 682 #define si_timerid si_timer1
 683 #endif
 684 #ifndef si_overrun
 685 #define si_overrun si_timer2
 686 #endif
 687
 688 static void
 689 compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from)
 690 {
 691   memset (to, 0, sizeof (*to));
 692
 693   to->si_signo = from->si_signo;
 694   to->si_errno = from->si_errno;
 695   to->si_code = from->si_code;
 696
 697   if (to->si_code < 0)
 698     {
 699       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 700     }
 701   else if (to->si_code == SI_USER)
 702     {
 703       to->cpt_si_pid = from->si_pid;
 704       to->cpt_si_uid = from->si_uid;
 705     }
 706   else if (to->si_code == SI_TIMER)
 707     {
 708       to->cpt_si_timerid = from->si_timerid;
 709       to->cpt_si_overrun = from->si_overrun;
 710       to->cpt_si_ptr = (intptr_t) from->si_ptr;
 711     }
 712   else
 713     {
 714       switch (to->si_signo)
 715         {
 716         case SIGCHLD:
 717           to->cpt_si_pid = from->si_pid;
 718           to->cpt_si_uid = from->si_uid;
 719           to->cpt_si_status = from->si_status;
 720           to->cpt_si_utime = from->si_utime;
 721           to->cpt_si_stime = from->si_stime;
 722           break;
 723         case SIGILL:
 724         case SIGFPE:
 725         case SIGSEGV:
 726         case SIGBUS:
 727           to->cpt_si_addr = (intptr_t) from->si_addr;
 728           break;
 729         case SIGPOLL:
 730           to->cpt_si_band = from->si_band;
 731           to->cpt_si_fd = from->si_fd;
 732           break;
 733         default:
 734           to->cpt_si_pid = from->si_pid;
 735           to->cpt_si_uid = from->si_uid;
 736           to->cpt_si_ptr = (intptr_t) from->si_ptr;
 737           break;
 738         }
 739     }
 740 }
 741
 742 static void
 743 siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from)
 744 {
 745   memset (to, 0, sizeof (*to));
 746
 747   to->si_signo = from->si_signo;
 748   to->si_errno = from->si_errno;
 749   to->si_code = from->si_code;
 750
 751   if (to->si_code < 0)
 752     {
 753       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 754     }
 755   else if (to->si_code == SI_USER)
 756     {
 757       to->si_pid = from->cpt_si_pid;
 758       to->si_uid = from->cpt_si_uid;
 759     }
 760   else if (to->si_code == SI_TIMER)
 761     {
 762       to->si_timerid = from->cpt_si_timerid;
 763       to->si_overrun = from->cpt_si_overrun;
 764       to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr;
 765     }
 766   else
 767     {
 768       switch (to->si_signo)
 769         {
 770         case SIGCHLD:
 771           to->si_pid = from->cpt_si_pid;
 772           to->si_uid = from->cpt_si_uid;
 773           to->si_status = from->cpt_si_status;
 774           to->si_utime = from->cpt_si_utime;
 775           to->si_stime = from->cpt_si_stime;
 776           break;
 777         case SIGILL:
 778         case SIGFPE:
 779         case SIGSEGV:
 780         case SIGBUS:
 781           to->si_addr = (void *) (intptr_t) from->cpt_si_addr;
 782           break;
 783         case SIGPOLL:
 784           to->si_band = from->cpt_si_band;
 785           to->si_fd = from->cpt_si_fd;
 786           break;
 787         default:
 788           to->si_pid = from->cpt_si_pid;
 789           to->si_uid = from->cpt_si_uid;
 790           to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr;
 791           break;
 792         }
 793     }
 794 }
 795
 796 #endif /* __x86_64__ */
 797
 798 /* Convert a native/host siginfo object, into/from the siginfo in the
 799    layout of the inferiors' architecture.  Returns true if any
 800    conversion was done; false otherwise.  If DIRECTION is 1, then copy
 801    from INF to NATIVE.  If DIRECTION is 0, copy from NATIVE to
 802    INF.  */
 803
 804 static int
 805 x86_siginfo_fixup (struct siginfo *native, void *inf, int direction)
 806 {
 807 #ifdef __x86_64__
 808   /* Is the inferior 32-bit?  If so, then fixup the siginfo object.  */
 809   if (register_size (0) == 4)
 810     {
 811       if (sizeof (struct siginfo) != sizeof (compat_siginfo_t))
 812         fatal ("unexpected difference in siginfo");
 813
 814       if (direction == 0)
 815         compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native);
 816       else
 817         siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf);
 818
 819       return 1;
 820     }
 821 #endif
 822
 823   return 0;
 824 }
 825 \f
 826 static int use_xml;
 827
 828 /* Update gdbserver_xmltarget.  */
 829
 830 static void
 831 x86_linux_update_xmltarget (void)
 832 {
 833   int pid;
 834   struct regset_info *regset;
 835   static unsigned long long xcr0;
 836   static int have_ptrace_getregset = -1;
 837 #ifdef HAVE_PTRACE_GETFPXREGS
 838   static int have_ptrace_getfpxregs = -1;
 839 #endif
 840
 841   if (!current_inferior)
 842     return;
 843
 844   pid = pid_of (get_thread_lwp (current_inferior));
 845 #ifdef __x86_64__
 846   if (num_xmm_registers == 8)
 847     init_registers_i386_linux ();
 848   else
 849     init_registers_amd64_linux ();
 850 #else
 851     {
 852 # ifdef HAVE_PTRACE_GETFPXREGS
 853       if (have_ptrace_getfpxregs == -1)
 854         {
 855           elf_fpxregset_t fpxregs;
 856
 857           if (ptrace (PTRACE_GETFPXREGS, pid, 0, (int) &fpxregs) < 0)
 858             {
 859               have_ptrace_getfpxregs = 0;
 860               x86_xcr0 = I386_XSTATE_X87_MASK;
 861
 862               /* Disable PTRACE_GETFPXREGS.  */
 863               for (regset = target_regsets;
 864                    regset->fill_function != NULL; regset++)
 865                 if (regset->get_request == PTRACE_GETFPXREGS)
 866                   {
 867                     regset->size = 0;
 868                     break;
 869                   }
 870             }
 871           else
 872             have_ptrace_getfpxregs = 1;
 873         }
 874
 875       if (!have_ptrace_getfpxregs)
 876         {
 877           init_registers_i386_mmx_linux ();
 878           return;
 879         }
 880 # endif
 881       init_registers_i386_linux ();
 882     }
 883 #endif
 884
 885   if (!use_xml)
 886     {
 887       /* Don't use XML.  */
 888 #ifdef __x86_64__
 889       if (num_xmm_registers == 8)
 890         gdbserver_xmltarget = xmltarget_i386_linux_no_xml;
 891       else
 892         gdbserver_xmltarget = xmltarget_amd64_linux_no_xml;
 893 #else
 894       gdbserver_xmltarget = xmltarget_i386_linux_no_xml;
 895 #endif
 896
 897       x86_xcr0 = I386_XSTATE_SSE_MASK;
 898
 899       return;
 900     }
 901
 902   /* Check if XSAVE extended state is supported.  */
 903   if (have_ptrace_getregset == -1)
 904     {
 905       unsigned long long xstateregs[I386_XSTATE_SSE_SIZE / sizeof (long long)];
 906       struct iovec iov;
 907
 908       iov.iov_base = xstateregs;
 909       iov.iov_len = sizeof (xstateregs);
 910
 911       /* Check if PTRACE_GETREGSET works.  */
 912       if (ptrace (PTRACE_GETREGSET, pid, (unsigned int) NT_X86_XSTATE,
 913                   &iov) < 0)
 914         {
 915           have_ptrace_getregset = 0;
 916           return;
 917         }
 918       else
 919         have_ptrace_getregset = 1;
 920
 921       /* Get XCR0 from XSAVE extended state at byte 464.  */
 922       xcr0 = xstateregs[464 / sizeof (long long)];
 923
 924       /* Use PTRACE_GETREGSET if it is available.  */
 925       for (regset = target_regsets;
 926            regset->fill_function != NULL; regset++)
 927         if (regset->get_request == PTRACE_GETREGSET)
 928           regset->size = I386_XSTATE_SIZE (xcr0);
 929         else if (regset->type != GENERAL_REGS)
 930           regset->size = 0;
 931     }
 932
 933   if (have_ptrace_getregset)
 934     {
 935       /* AVX is the highest feature we support.  */
 936       if ((xcr0 & I386_XSTATE_AVX_MASK) == I386_XSTATE_AVX_MASK)
 937         {
 938           x86_xcr0 = xcr0;
 939
 940 #ifdef __x86_64__
 941           /* I386 has 8 xmm regs.  */
 942           if (num_xmm_registers == 8)
 943             init_registers_i386_avx_linux ();
 944           else
 945             init_registers_amd64_avx_linux ();
 946 #else
 947           init_registers_i386_avx_linux ();
 948 #endif
 949         }
 950     }
 951 }
 952
 953 /* Process qSupported query, "xmlRegisters=".  Update the buffer size for
 954    PTRACE_GETREGSET.  */
 955
 956 static void
 957 x86_linux_process_qsupported (const char *query)
 958 {
 959   /* Return if gdb doesn't support XML.  If gdb sends "xmlRegisters="
 960      with "i386" in qSupported query, it supports x86 XML target
 961      descriptions.  */
 962   use_xml = 0;
 963   if (query != NULL && strncmp (query, "xmlRegisters=", 13) == 0)
 964     {
 965       char *copy = xstrdup (query + 13);
 966       char *p;
 967
 968       for (p = strtok (copy, ","); p != NULL; p = strtok (NULL, ","))
 969         {
 970           if (strcmp (p, "i386") == 0)
 971             {
 972               use_xml = 1;
 973               break;
 974             }
 975         }
 976
 977       free (copy);
 978     }
 979
 980   x86_linux_update_xmltarget ();
 981 }
 982
 983 /* Initialize gdbserver for the architecture of the inferior.  */
 984
 985 static void
 986 x86_arch_setup (void)
 987 {
 988 #ifdef __x86_64__
 989   int pid = pid_of (get_thread_lwp (current_inferior));
 990   char *file = linux_child_pid_to_exec_file (pid);
 991   int use_64bit = elf_64_file_p (file);
 992
 993   free (file);
 994
 995   if (use_64bit < 0)
 996     {
 997       /* This can only happen if /proc/<pid>/exe is unreadable,
 998          but "that can't happen" if we've gotten this far.
 999          Fall through and assume this is a 32-bit program.  */
1000     }
1001   else if (use_64bit)
1002     {
1003       /* Amd64 doesn't have HAVE_LINUX_USRREGS.  */
1004       the_low_target.num_regs = -1;
1005       the_low_target.regmap = NULL;
1006       the_low_target.cannot_fetch_register = NULL;
1007       the_low_target.cannot_store_register = NULL;
1008
1009       /* Amd64 has 16 xmm regs.  */
1010       num_xmm_registers = 16;
1011
1012       x86_linux_update_xmltarget ();
1013       return;
1014     }
1015 #endif
1016
1017   /* Ok we have a 32-bit inferior.  */
1018
1019   the_low_target.num_regs = I386_NUM_REGS;
1020   the_low_target.regmap = i386_regmap;
1021   the_low_target.cannot_fetch_register = i386_cannot_fetch_register;
1022   the_low_target.cannot_store_register = i386_cannot_store_register;
1023
1024   /* I386 has 8 xmm regs.  */
1025   num_xmm_registers = 8;
1026
1027   x86_linux_update_xmltarget ();
1028 }
1029
1030 static int
1031 x86_supports_tracepoints (void)
1032 {
1033   return 1;
1034 }
1035
1036 /* This is initialized assuming an amd64 target.
1037    x86_arch_setup will correct it for i386 or amd64 targets.  */
1038
1039 struct linux_target_ops the_low_target =
1040 {
1041   x86_arch_setup,
1042   -1,
1043   NULL,
1044   NULL,
1045   NULL,
1046   x86_get_pc,
1047   x86_set_pc,
1048   x86_breakpoint,
1049   x86_breakpoint_len,
1050   NULL,
1051   1,
1052   x86_breakpoint_at,
1053   x86_insert_point,
1054   x86_remove_point,
1055   x86_stopped_by_watchpoint,
1056   x86_stopped_data_address,
1057   /* collect_ptrace_register/supply_ptrace_register are not needed in the
1058      native i386 case (no registers smaller than an xfer unit), and are not
1059      used in the biarch case (HAVE_LINUX_USRREGS is not defined).  */
1060   NULL,
1061   NULL,
1062   /* need to fix up i386 siginfo if host is amd64 */
1063   x86_siginfo_fixup,
1064   x86_linux_new_process,
1065   x86_linux_new_thread,
1066   x86_linux_prepare_to_resume,
1067   x86_linux_process_qsupported,
1068   x86_supports_tracepoints
1069 };