amd64-linux-nat.c revision 1.1
1/* Native-dependent code for GNU/Linux x86-64. 2 3 Copyright (C) 2001-2014 Free Software Foundation, Inc. 4 Contributed by Jiri Smid, SuSE Labs. 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 "defs.h" 22#include "inferior.h" 23#include "gdbcore.h" 24#include "regcache.h" 25#include "regset.h" 26#include "linux-nat.h" 27#include "amd64-linux-tdep.h" 28#include "linux-btrace.h" 29#include "btrace.h" 30 31#include "gdb_assert.h" 32#include <string.h> 33#include "elf/common.h" 34#include <sys/uio.h> 35#include <sys/ptrace.h> 36#include <sys/debugreg.h> 37#include <sys/syscall.h> 38#include <sys/procfs.h> 39#include <sys/user.h> 40#include <asm/prctl.h> 41/* FIXME ezannoni-2003-07-09: we need <sys/reg.h> to be included after 42 <asm/ptrace.h> because the latter redefines FS and GS for no apparent 43 reason, and those definitions don't match the ones that libpthread_db 44 uses, which come from <sys/reg.h>. */ 45/* ezannoni-2003-07-09: I think this is fixed. The extraneous defs have 46 been removed from ptrace.h in the kernel. However, better safe than 47 sorry. */ 48#include <asm/ptrace.h> 49#include <sys/reg.h> 50#include "gdb_proc_service.h" 51 52/* Prototypes for supply_gregset etc. */ 53#include "gregset.h" 54 55#include "amd64-tdep.h" 56#include "i386-linux-tdep.h" 57#include "amd64-nat.h" 58#include "i386-nat.h" 59#include "i386-xstate.h" 60 61#ifndef PTRACE_GETREGSET 62#define PTRACE_GETREGSET 0x4204 63#endif 64 65#ifndef PTRACE_SETREGSET 66#define PTRACE_SETREGSET 0x4205 67#endif 68 69/* Per-thread arch-specific data we want to keep. */ 70 71struct arch_lwp_info 72{ 73 /* Non-zero if our copy differs from what's recorded in the thread. */ 74 int debug_registers_changed; 75}; 76 77/* Does the current host support PTRACE_GETREGSET? */ 78static int have_ptrace_getregset = -1; 79 80/* Mapping between the general-purpose registers in GNU/Linux x86-64 81 `struct user' format and GDB's register cache layout for GNU/Linux 82 i386. 83 84 Note that most GNU/Linux x86-64 registers are 64-bit, while the 85 GNU/Linux i386 registers are all 32-bit, but since we're 86 little-endian we get away with that. */ 87 88/* From <sys/reg.h> on GNU/Linux i386. */ 89static int amd64_linux_gregset32_reg_offset[] = 90{ 91 RAX * 8, RCX * 8, /* %eax, %ecx */ 92 RDX * 8, RBX * 8, /* %edx, %ebx */ 93 RSP * 8, RBP * 8, /* %esp, %ebp */ 94 RSI * 8, RDI * 8, /* %esi, %edi */ 95 RIP * 8, EFLAGS * 8, /* %eip, %eflags */ 96 CS * 8, SS * 8, /* %cs, %ss */ 97 DS * 8, ES * 8, /* %ds, %es */ 98 FS * 8, GS * 8, /* %fs, %gs */ 99 -1, -1, -1, -1, -1, -1, -1, -1, 100 -1, -1, -1, -1, -1, -1, -1, -1, 101 -1, -1, -1, -1, -1, -1, -1, -1, -1, 102 -1, -1, -1, -1, -1, -1, -1, -1, 103 -1, -1, -1, -1, /* MPX registers BND0 ... BND3. */ 104 -1, -1, /* MPX registers BNDCFGU, BNDSTATUS. */ 105 ORIG_RAX * 8, /* "orig_eax" */ 106}; 107 108 109/* Transfering the general-purpose registers between GDB, inferiors 110 and core files. */ 111 112/* Fill GDB's register cache with the general-purpose register values 113 in *GREGSETP. */ 114 115void 116supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp) 117{ 118 amd64_supply_native_gregset (regcache, gregsetp, -1); 119} 120 121/* Fill register REGNUM (if it is a general-purpose register) in 122 *GREGSETP with the value in GDB's register cache. If REGNUM is -1, 123 do this for all registers. */ 124 125void 126fill_gregset (const struct regcache *regcache, 127 elf_gregset_t *gregsetp, int regnum) 128{ 129 amd64_collect_native_gregset (regcache, gregsetp, regnum); 130} 131 132/* Transfering floating-point registers between GDB, inferiors and cores. */ 133 134/* Fill GDB's register cache with the floating-point and SSE register 135 values in *FPREGSETP. */ 136 137void 138supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp) 139{ 140 amd64_supply_fxsave (regcache, -1, fpregsetp); 141} 142 143/* Fill register REGNUM (if it is a floating-point or SSE register) in 144 *FPREGSETP with the value in GDB's register cache. If REGNUM is 145 -1, do this for all registers. */ 146 147void 148fill_fpregset (const struct regcache *regcache, 149 elf_fpregset_t *fpregsetp, int regnum) 150{ 151 amd64_collect_fxsave (regcache, regnum, fpregsetp); 152} 153 154 155/* Transferring arbitrary registers between GDB and inferior. */ 156 157/* Fetch register REGNUM from the child process. If REGNUM is -1, do 158 this for all registers (including the floating point and SSE 159 registers). */ 160 161static void 162amd64_linux_fetch_inferior_registers (struct target_ops *ops, 163 struct regcache *regcache, int regnum) 164{ 165 struct gdbarch *gdbarch = get_regcache_arch (regcache); 166 int tid; 167 168 /* GNU/Linux LWP ID's are process ID's. */ 169 tid = ptid_get_lwp (inferior_ptid); 170 if (tid == 0) 171 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */ 172 173 if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum)) 174 { 175 elf_gregset_t regs; 176 177 if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0) 178 perror_with_name (_("Couldn't get registers")); 179 180 amd64_supply_native_gregset (regcache, ®s, -1); 181 if (regnum != -1) 182 return; 183 } 184 185 if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum)) 186 { 187 elf_fpregset_t fpregs; 188 189 if (have_ptrace_getregset) 190 { 191 char xstateregs[I386_XSTATE_MAX_SIZE]; 192 struct iovec iov; 193 194 iov.iov_base = xstateregs; 195 iov.iov_len = sizeof (xstateregs); 196 if (ptrace (PTRACE_GETREGSET, tid, 197 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) 198 perror_with_name (_("Couldn't get extended state status")); 199 200 amd64_supply_xsave (regcache, -1, xstateregs); 201 } 202 else 203 { 204 if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) 205 perror_with_name (_("Couldn't get floating point status")); 206 207 amd64_supply_fxsave (regcache, -1, &fpregs); 208 } 209 } 210} 211 212/* Store register REGNUM back into the child process. If REGNUM is 213 -1, do this for all registers (including the floating-point and SSE 214 registers). */ 215 216static void 217amd64_linux_store_inferior_registers (struct target_ops *ops, 218 struct regcache *regcache, int regnum) 219{ 220 struct gdbarch *gdbarch = get_regcache_arch (regcache); 221 int tid; 222 223 /* GNU/Linux LWP ID's are process ID's. */ 224 tid = ptid_get_lwp (inferior_ptid); 225 if (tid == 0) 226 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */ 227 228 if (regnum == -1 || amd64_native_gregset_supplies_p (gdbarch, regnum)) 229 { 230 elf_gregset_t regs; 231 232 if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0) 233 perror_with_name (_("Couldn't get registers")); 234 235 amd64_collect_native_gregset (regcache, ®s, regnum); 236 237 if (ptrace (PTRACE_SETREGS, tid, 0, (long) ®s) < 0) 238 perror_with_name (_("Couldn't write registers")); 239 240 if (regnum != -1) 241 return; 242 } 243 244 if (regnum == -1 || !amd64_native_gregset_supplies_p (gdbarch, regnum)) 245 { 246 elf_fpregset_t fpregs; 247 248 if (have_ptrace_getregset) 249 { 250 char xstateregs[I386_XSTATE_MAX_SIZE]; 251 struct iovec iov; 252 253 iov.iov_base = xstateregs; 254 iov.iov_len = sizeof (xstateregs); 255 if (ptrace (PTRACE_GETREGSET, tid, 256 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) 257 perror_with_name (_("Couldn't get extended state status")); 258 259 amd64_collect_xsave (regcache, regnum, xstateregs, 0); 260 261 if (ptrace (PTRACE_SETREGSET, tid, 262 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) 263 perror_with_name (_("Couldn't write extended state status")); 264 } 265 else 266 { 267 if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) 268 perror_with_name (_("Couldn't get floating point status")); 269 270 amd64_collect_fxsave (regcache, regnum, &fpregs); 271 272 if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0) 273 perror_with_name (_("Couldn't write floating point status")); 274 } 275 } 276} 277 278/* Support for debug registers. */ 279 280static unsigned long 281amd64_linux_dr_get (ptid_t ptid, int regnum) 282{ 283 int tid; 284 unsigned long value; 285 286 tid = ptid_get_lwp (ptid); 287 if (tid == 0) 288 tid = ptid_get_pid (ptid); 289 290 errno = 0; 291 value = ptrace (PTRACE_PEEKUSER, tid, 292 offsetof (struct user, u_debugreg[regnum]), 0); 293 if (errno != 0) 294 perror_with_name (_("Couldn't read debug register")); 295 296 return value; 297} 298 299/* Set debug register REGNUM to VALUE in only the one LWP of PTID. */ 300 301static void 302amd64_linux_dr_set (ptid_t ptid, int regnum, unsigned long value) 303{ 304 int tid; 305 306 tid = ptid_get_lwp (ptid); 307 if (tid == 0) 308 tid = ptid_get_pid (ptid); 309 310 errno = 0; 311 ptrace (PTRACE_POKEUSER, tid, 312 offsetof (struct user, u_debugreg[regnum]), value); 313 if (errno != 0) 314 perror_with_name (_("Couldn't write debug register")); 315} 316 317/* Return the inferior's debug register REGNUM. */ 318 319static CORE_ADDR 320amd64_linux_dr_get_addr (int regnum) 321{ 322 /* DR6 and DR7 are retrieved with some other way. */ 323 gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR); 324 325 return amd64_linux_dr_get (inferior_ptid, regnum); 326} 327 328/* Return the inferior's DR7 debug control register. */ 329 330static unsigned long 331amd64_linux_dr_get_control (void) 332{ 333 return amd64_linux_dr_get (inferior_ptid, DR_CONTROL); 334} 335 336/* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */ 337 338static unsigned long 339amd64_linux_dr_get_status (void) 340{ 341 return amd64_linux_dr_get (inferior_ptid, DR_STATUS); 342} 343 344/* Callback for iterate_over_lwps. Update the debug registers of 345 LWP. */ 346 347static int 348update_debug_registers_callback (struct lwp_info *lwp, void *arg) 349{ 350 if (lwp->arch_private == NULL) 351 lwp->arch_private = XCNEW (struct arch_lwp_info); 352 353 /* The actual update is done later just before resuming the lwp, we 354 just mark that the registers need updating. */ 355 lwp->arch_private->debug_registers_changed = 1; 356 357 /* If the lwp isn't stopped, force it to momentarily pause, so we 358 can update its debug registers. */ 359 if (!lwp->stopped) 360 linux_stop_lwp (lwp); 361 362 /* Continue the iteration. */ 363 return 0; 364} 365 366/* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */ 367 368static void 369amd64_linux_dr_set_control (unsigned long control) 370{ 371 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 372 373 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL); 374} 375 376/* Set address REGNUM (zero based) to ADDR in all LWPs of the current 377 inferior. */ 378 379static void 380amd64_linux_dr_set_addr (int regnum, CORE_ADDR addr) 381{ 382 ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 383 384 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); 385 386 iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL); 387} 388 389/* Called when resuming a thread. 390 If the debug regs have changed, update the thread's copies. */ 391 392static void 393amd64_linux_prepare_to_resume (struct lwp_info *lwp) 394{ 395 int clear_status = 0; 396 397 /* NULL means this is the main thread still going through the shell, 398 or, no watchpoint has been set yet. In that case, there's 399 nothing to do. */ 400 if (lwp->arch_private == NULL) 401 return; 402 403 if (lwp->arch_private->debug_registers_changed) 404 { 405 struct i386_debug_reg_state *state 406 = i386_debug_reg_state (ptid_get_pid (lwp->ptid)); 407 int i; 408 409 /* On Linux kernel before 2.6.33 commit 410 72f674d203cd230426437cdcf7dd6f681dad8b0d 411 if you enable a breakpoint by the DR_CONTROL bits you need to have 412 already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers. 413 414 Ensure DR_CONTROL gets written as the very last register here. */ 415 416 for (i = DR_FIRSTADDR; i <= DR_LASTADDR; i++) 417 if (state->dr_ref_count[i] > 0) 418 { 419 amd64_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]); 420 421 /* If we're setting a watchpoint, any change the inferior 422 had done itself to the debug registers needs to be 423 discarded, otherwise, i386_stopped_data_address can get 424 confused. */ 425 clear_status = 1; 426 } 427 428 amd64_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror); 429 430 lwp->arch_private->debug_registers_changed = 0; 431 } 432 433 if (clear_status || lwp->stopped_by_watchpoint) 434 amd64_linux_dr_set (lwp->ptid, DR_STATUS, 0); 435} 436 437static void 438amd64_linux_new_thread (struct lwp_info *lp) 439{ 440 struct arch_lwp_info *info = XCNEW (struct arch_lwp_info); 441 442 info->debug_registers_changed = 1; 443 444 lp->arch_private = info; 445} 446 447/* linux_nat_new_fork hook. */ 448 449static void 450amd64_linux_new_fork (struct lwp_info *parent, pid_t child_pid) 451{ 452 pid_t parent_pid; 453 struct i386_debug_reg_state *parent_state; 454 struct i386_debug_reg_state *child_state; 455 456 /* NULL means no watchpoint has ever been set in the parent. In 457 that case, there's nothing to do. */ 458 if (parent->arch_private == NULL) 459 return; 460 461 /* Linux kernel before 2.6.33 commit 462 72f674d203cd230426437cdcf7dd6f681dad8b0d 463 will inherit hardware debug registers from parent 464 on fork/vfork/clone. Newer Linux kernels create such tasks with 465 zeroed debug registers. 466 467 GDB core assumes the child inherits the watchpoints/hw 468 breakpoints of the parent, and will remove them all from the 469 forked off process. Copy the debug registers mirrors into the 470 new process so that all breakpoints and watchpoints can be 471 removed together. The debug registers mirror will become zeroed 472 in the end before detaching the forked off process, thus making 473 this compatible with older Linux kernels too. */ 474 475 parent_pid = ptid_get_pid (parent->ptid); 476 parent_state = i386_debug_reg_state (parent_pid); 477 child_state = i386_debug_reg_state (child_pid); 478 *child_state = *parent_state; 479} 480 481 482 483/* This function is called by libthread_db as part of its handling of 484 a request for a thread's local storage address. */ 485 486ps_err_e 487ps_get_thread_area (const struct ps_prochandle *ph, 488 lwpid_t lwpid, int idx, void **base) 489{ 490 if (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 32) 491 { 492 /* The full structure is found in <asm-i386/ldt.h>. The second 493 integer is the LDT's base_address and that is used to locate 494 the thread's local storage. See i386-linux-nat.c more 495 info. */ 496 unsigned int desc[4]; 497 498 /* This code assumes that "int" is 32 bits and that 499 GET_THREAD_AREA returns no more than 4 int values. */ 500 gdb_assert (sizeof (int) == 4); 501#ifndef PTRACE_GET_THREAD_AREA 502#define PTRACE_GET_THREAD_AREA 25 503#endif 504 if (ptrace (PTRACE_GET_THREAD_AREA, 505 lwpid, (void *) (long) idx, (unsigned long) &desc) < 0) 506 return PS_ERR; 507 508 /* Extend the value to 64 bits. Here it's assumed that a "long" 509 and a "void *" are the same. */ 510 (*base) = (void *) (long) desc[1]; 511 return PS_OK; 512 } 513 else 514 { 515 /* This definition comes from prctl.h, but some kernels may not 516 have it. */ 517#ifndef PTRACE_ARCH_PRCTL 518#define PTRACE_ARCH_PRCTL 30 519#endif 520 /* FIXME: ezannoni-2003-07-09 see comment above about include 521 file order. We could be getting bogus values for these two. */ 522 gdb_assert (FS < ELF_NGREG); 523 gdb_assert (GS < ELF_NGREG); 524 switch (idx) 525 { 526 case FS: 527#ifdef HAVE_STRUCT_USER_REGS_STRUCT_FS_BASE 528 { 529 /* PTRACE_ARCH_PRCTL is obsolete since 2.6.25, where the 530 fs_base and gs_base fields of user_regs_struct can be 531 used directly. */ 532 unsigned long fs; 533 errno = 0; 534 fs = ptrace (PTRACE_PEEKUSER, lwpid, 535 offsetof (struct user_regs_struct, fs_base), 0); 536 if (errno == 0) 537 { 538 *base = (void *) fs; 539 return PS_OK; 540 } 541 } 542#endif 543 if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_FS) == 0) 544 return PS_OK; 545 break; 546 case GS: 547#ifdef HAVE_STRUCT_USER_REGS_STRUCT_GS_BASE 548 { 549 unsigned long gs; 550 errno = 0; 551 gs = ptrace (PTRACE_PEEKUSER, lwpid, 552 offsetof (struct user_regs_struct, gs_base), 0); 553 if (errno == 0) 554 { 555 *base = (void *) gs; 556 return PS_OK; 557 } 558 } 559#endif 560 if (ptrace (PTRACE_ARCH_PRCTL, lwpid, base, ARCH_GET_GS) == 0) 561 return PS_OK; 562 break; 563 default: /* Should not happen. */ 564 return PS_BADADDR; 565 } 566 } 567 return PS_ERR; /* ptrace failed. */ 568} 569 570 571static void (*super_post_startup_inferior) (ptid_t ptid); 572 573static void 574amd64_linux_child_post_startup_inferior (ptid_t ptid) 575{ 576 i386_cleanup_dregs (); 577 super_post_startup_inferior (ptid); 578} 579 580 581/* When GDB is built as a 64-bit application on linux, the 582 PTRACE_GETSIGINFO data is always presented in 64-bit layout. Since 583 debugging a 32-bit inferior with a 64-bit GDB should look the same 584 as debugging it with a 32-bit GDB, we do the 32-bit <-> 64-bit 585 conversion in-place ourselves. */ 586 587/* These types below (compat_*) define a siginfo type that is layout 588 compatible with the siginfo type exported by the 32-bit userspace 589 support. */ 590 591typedef int compat_int_t; 592typedef unsigned int compat_uptr_t; 593 594typedef int compat_time_t; 595typedef int compat_timer_t; 596typedef int compat_clock_t; 597 598struct compat_timeval 599{ 600 compat_time_t tv_sec; 601 int tv_usec; 602}; 603 604typedef union compat_sigval 605{ 606 compat_int_t sival_int; 607 compat_uptr_t sival_ptr; 608} compat_sigval_t; 609 610typedef struct compat_siginfo 611{ 612 int si_signo; 613 int si_errno; 614 int si_code; 615 616 union 617 { 618 int _pad[((128 / sizeof (int)) - 3)]; 619 620 /* kill() */ 621 struct 622 { 623 unsigned int _pid; 624 unsigned int _uid; 625 } _kill; 626 627 /* POSIX.1b timers */ 628 struct 629 { 630 compat_timer_t _tid; 631 int _overrun; 632 compat_sigval_t _sigval; 633 } _timer; 634 635 /* POSIX.1b signals */ 636 struct 637 { 638 unsigned int _pid; 639 unsigned int _uid; 640 compat_sigval_t _sigval; 641 } _rt; 642 643 /* SIGCHLD */ 644 struct 645 { 646 unsigned int _pid; 647 unsigned int _uid; 648 int _status; 649 compat_clock_t _utime; 650 compat_clock_t _stime; 651 } _sigchld; 652 653 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ 654 struct 655 { 656 unsigned int _addr; 657 } _sigfault; 658 659 /* SIGPOLL */ 660 struct 661 { 662 int _band; 663 int _fd; 664 } _sigpoll; 665 } _sifields; 666} compat_siginfo_t; 667 668/* For x32, clock_t in _sigchld is 64bit aligned at 4 bytes. */ 669typedef struct compat_x32_clock 670{ 671 int lower; 672 int upper; 673} compat_x32_clock_t; 674 675typedef struct compat_x32_siginfo 676{ 677 int si_signo; 678 int si_errno; 679 int si_code; 680 681 union 682 { 683 int _pad[((128 / sizeof (int)) - 3)]; 684 685 /* kill() */ 686 struct 687 { 688 unsigned int _pid; 689 unsigned int _uid; 690 } _kill; 691 692 /* POSIX.1b timers */ 693 struct 694 { 695 compat_timer_t _tid; 696 int _overrun; 697 compat_sigval_t _sigval; 698 } _timer; 699 700 /* POSIX.1b signals */ 701 struct 702 { 703 unsigned int _pid; 704 unsigned int _uid; 705 compat_sigval_t _sigval; 706 } _rt; 707 708 /* SIGCHLD */ 709 struct 710 { 711 unsigned int _pid; 712 unsigned int _uid; 713 int _status; 714 compat_x32_clock_t _utime; 715 compat_x32_clock_t _stime; 716 } _sigchld; 717 718 /* SIGILL, SIGFPE, SIGSEGV, SIGBUS */ 719 struct 720 { 721 unsigned int _addr; 722 } _sigfault; 723 724 /* SIGPOLL */ 725 struct 726 { 727 int _band; 728 int _fd; 729 } _sigpoll; 730 } _sifields; 731} compat_x32_siginfo_t; 732 733#define cpt_si_pid _sifields._kill._pid 734#define cpt_si_uid _sifields._kill._uid 735#define cpt_si_timerid _sifields._timer._tid 736#define cpt_si_overrun _sifields._timer._overrun 737#define cpt_si_status _sifields._sigchld._status 738#define cpt_si_utime _sifields._sigchld._utime 739#define cpt_si_stime _sifields._sigchld._stime 740#define cpt_si_ptr _sifields._rt._sigval.sival_ptr 741#define cpt_si_addr _sifields._sigfault._addr 742#define cpt_si_band _sifields._sigpoll._band 743#define cpt_si_fd _sifields._sigpoll._fd 744 745/* glibc at least up to 2.3.2 doesn't have si_timerid, si_overrun. 746 In their place is si_timer1,si_timer2. */ 747#ifndef si_timerid 748#define si_timerid si_timer1 749#endif 750#ifndef si_overrun 751#define si_overrun si_timer2 752#endif 753 754static void 755compat_siginfo_from_siginfo (compat_siginfo_t *to, siginfo_t *from) 756{ 757 memset (to, 0, sizeof (*to)); 758 759 to->si_signo = from->si_signo; 760 to->si_errno = from->si_errno; 761 to->si_code = from->si_code; 762 763 if (to->si_code == SI_TIMER) 764 { 765 to->cpt_si_timerid = from->si_timerid; 766 to->cpt_si_overrun = from->si_overrun; 767 to->cpt_si_ptr = (intptr_t) from->si_ptr; 768 } 769 else if (to->si_code == SI_USER) 770 { 771 to->cpt_si_pid = from->si_pid; 772 to->cpt_si_uid = from->si_uid; 773 } 774 else if (to->si_code < 0) 775 { 776 to->cpt_si_pid = from->si_pid; 777 to->cpt_si_uid = from->si_uid; 778 to->cpt_si_ptr = (intptr_t) from->si_ptr; 779 } 780 else 781 { 782 switch (to->si_signo) 783 { 784 case SIGCHLD: 785 to->cpt_si_pid = from->si_pid; 786 to->cpt_si_uid = from->si_uid; 787 to->cpt_si_status = from->si_status; 788 to->cpt_si_utime = from->si_utime; 789 to->cpt_si_stime = from->si_stime; 790 break; 791 case SIGILL: 792 case SIGFPE: 793 case SIGSEGV: 794 case SIGBUS: 795 to->cpt_si_addr = (intptr_t) from->si_addr; 796 break; 797 case SIGPOLL: 798 to->cpt_si_band = from->si_band; 799 to->cpt_si_fd = from->si_fd; 800 break; 801 default: 802 to->cpt_si_pid = from->si_pid; 803 to->cpt_si_uid = from->si_uid; 804 to->cpt_si_ptr = (intptr_t) from->si_ptr; 805 break; 806 } 807 } 808} 809 810static void 811siginfo_from_compat_siginfo (siginfo_t *to, compat_siginfo_t *from) 812{ 813 memset (to, 0, sizeof (*to)); 814 815 to->si_signo = from->si_signo; 816 to->si_errno = from->si_errno; 817 to->si_code = from->si_code; 818 819 if (to->si_code == SI_TIMER) 820 { 821 to->si_timerid = from->cpt_si_timerid; 822 to->si_overrun = from->cpt_si_overrun; 823 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; 824 } 825 else if (to->si_code == SI_USER) 826 { 827 to->si_pid = from->cpt_si_pid; 828 to->si_uid = from->cpt_si_uid; 829 } 830 if (to->si_code < 0) 831 { 832 to->si_pid = from->cpt_si_pid; 833 to->si_uid = from->cpt_si_uid; 834 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; 835 } 836 else 837 { 838 switch (to->si_signo) 839 { 840 case SIGCHLD: 841 to->si_pid = from->cpt_si_pid; 842 to->si_uid = from->cpt_si_uid; 843 to->si_status = from->cpt_si_status; 844 to->si_utime = from->cpt_si_utime; 845 to->si_stime = from->cpt_si_stime; 846 break; 847 case SIGILL: 848 case SIGFPE: 849 case SIGSEGV: 850 case SIGBUS: 851 to->si_addr = (void *) (intptr_t) from->cpt_si_addr; 852 break; 853 case SIGPOLL: 854 to->si_band = from->cpt_si_band; 855 to->si_fd = from->cpt_si_fd; 856 break; 857 default: 858 to->si_pid = from->cpt_si_pid; 859 to->si_uid = from->cpt_si_uid; 860 to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr; 861 break; 862 } 863 } 864} 865 866static void 867compat_x32_siginfo_from_siginfo (compat_x32_siginfo_t *to, 868 siginfo_t *from) 869{ 870 memset (to, 0, sizeof (*to)); 871 872 to->si_signo = from->si_signo; 873 to->si_errno = from->si_errno; 874 to->si_code = from->si_code; 875 876 if (to->si_code == SI_TIMER) 877 { 878 to->cpt_si_timerid = from->si_timerid; 879 to->cpt_si_overrun = from->si_overrun; 880 to->cpt_si_ptr = (intptr_t) from->si_ptr; 881 } 882 else if (to->si_code == SI_USER) 883 { 884 to->cpt_si_pid = from->si_pid; 885 to->cpt_si_uid = from->si_uid; 886 } 887 else if (to->si_code < 0) 888 { 889 to->cpt_si_pid = from->si_pid; 890 to->cpt_si_uid = from->si_uid; 891 to->cpt_si_ptr = (intptr_t) from->si_ptr; 892 } 893 else 894 { 895 switch (to->si_signo) 896 { 897 case SIGCHLD: 898 to->cpt_si_pid = from->si_pid; 899 to->cpt_si_uid = from->si_uid; 900 to->cpt_si_status = from->si_status; 901 memcpy (&to->cpt_si_utime, &from->si_utime, 902 sizeof (to->cpt_si_utime)); 903 memcpy (&to->cpt_si_stime, &from->si_stime, 904 sizeof (to->cpt_si_stime)); 905 break; 906 case SIGILL: 907 case SIGFPE: 908 case SIGSEGV: 909 case SIGBUS: 910 to->cpt_si_addr = (intptr_t) from->si_addr; 911 break; 912 case SIGPOLL: 913 to->cpt_si_band = from->si_band; 914 to->cpt_si_fd = from->si_fd; 915 break; 916 default: 917 to->cpt_si_pid = from->si_pid; 918 to->cpt_si_uid = from->si_uid; 919 to->cpt_si_ptr = (intptr_t) from->si_ptr; 920 break; 921 } 922 } 923} 924 925static void 926siginfo_from_compat_x32_siginfo (siginfo_t *to, 927 compat_x32_siginfo_t *from) 928{ 929 memset (to, 0, sizeof (*to)); 930 931 to->si_signo = from->si_signo; 932 to->si_errno = from->si_errno; 933 to->si_code = from->si_code; 934 935 if (to->si_code == SI_TIMER) 936 { 937 to->si_timerid = from->cpt_si_timerid; 938 to->si_overrun = from->cpt_si_overrun; 939 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; 940 } 941 else if (to->si_code == SI_USER) 942 { 943 to->si_pid = from->cpt_si_pid; 944 to->si_uid = from->cpt_si_uid; 945 } 946 if (to->si_code < 0) 947 { 948 to->si_pid = from->cpt_si_pid; 949 to->si_uid = from->cpt_si_uid; 950 to->si_ptr = (void *) (intptr_t) from->cpt_si_ptr; 951 } 952 else 953 { 954 switch (to->si_signo) 955 { 956 case SIGCHLD: 957 to->si_pid = from->cpt_si_pid; 958 to->si_uid = from->cpt_si_uid; 959 to->si_status = from->cpt_si_status; 960 memcpy (&to->si_utime, &from->cpt_si_utime, 961 sizeof (to->si_utime)); 962 memcpy (&to->si_stime, &from->cpt_si_stime, 963 sizeof (to->si_stime)); 964 break; 965 case SIGILL: 966 case SIGFPE: 967 case SIGSEGV: 968 case SIGBUS: 969 to->si_addr = (void *) (intptr_t) from->cpt_si_addr; 970 break; 971 case SIGPOLL: 972 to->si_band = from->cpt_si_band; 973 to->si_fd = from->cpt_si_fd; 974 break; 975 default: 976 to->si_pid = from->cpt_si_pid; 977 to->si_uid = from->cpt_si_uid; 978 to->si_ptr = (void* ) (intptr_t) from->cpt_si_ptr; 979 break; 980 } 981 } 982} 983 984/* Convert a native/host siginfo object, into/from the siginfo in the 985 layout of the inferiors' architecture. Returns true if any 986 conversion was done; false otherwise. If DIRECTION is 1, then copy 987 from INF to NATIVE. If DIRECTION is 0, copy from NATIVE to 988 INF. */ 989 990static int 991amd64_linux_siginfo_fixup (siginfo_t *native, gdb_byte *inf, int direction) 992{ 993 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ()); 994 995 /* Is the inferior 32-bit? If so, then do fixup the siginfo 996 object. */ 997 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32) 998 { 999 gdb_assert (sizeof (siginfo_t) == sizeof (compat_siginfo_t)); 1000 1001 if (direction == 0) 1002 compat_siginfo_from_siginfo ((struct compat_siginfo *) inf, native); 1003 else 1004 siginfo_from_compat_siginfo (native, (struct compat_siginfo *) inf); 1005 1006 return 1; 1007 } 1008 /* No fixup for native x32 GDB. */ 1009 else if (gdbarch_addr_bit (gdbarch) == 32 && sizeof (void *) == 8) 1010 { 1011 gdb_assert (sizeof (siginfo_t) == sizeof (compat_x32_siginfo_t)); 1012 1013 if (direction == 0) 1014 compat_x32_siginfo_from_siginfo ((struct compat_x32_siginfo *) inf, 1015 native); 1016 else 1017 siginfo_from_compat_x32_siginfo (native, 1018 (struct compat_x32_siginfo *) inf); 1019 1020 return 1; 1021 } 1022 else 1023 return 0; 1024} 1025 1026/* Get Linux/x86 target description from running target. 1027 1028 Value of CS segment register: 1029 1. 64bit process: 0x33. 1030 2. 32bit process: 0x23. 1031 1032 Value of DS segment register: 1033 1. LP64 process: 0x0. 1034 2. X32 process: 0x2b. 1035 */ 1036 1037#define AMD64_LINUX_USER64_CS 0x33 1038#define AMD64_LINUX_X32_DS 0x2b 1039 1040static const struct target_desc * 1041amd64_linux_read_description (struct target_ops *ops) 1042{ 1043 unsigned long cs; 1044 unsigned long ds; 1045 int tid; 1046 int is_64bit; 1047 int is_x32; 1048 static uint64_t xcr0; 1049 1050 /* GNU/Linux LWP ID's are process ID's. */ 1051 tid = ptid_get_lwp (inferior_ptid); 1052 if (tid == 0) 1053 tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */ 1054 1055 /* Get CS register. */ 1056 errno = 0; 1057 cs = ptrace (PTRACE_PEEKUSER, tid, 1058 offsetof (struct user_regs_struct, cs), 0); 1059 if (errno != 0) 1060 perror_with_name (_("Couldn't get CS register")); 1061 1062 is_64bit = cs == AMD64_LINUX_USER64_CS; 1063 1064 /* Get DS register. */ 1065 errno = 0; 1066 ds = ptrace (PTRACE_PEEKUSER, tid, 1067 offsetof (struct user_regs_struct, ds), 0); 1068 if (errno != 0) 1069 perror_with_name (_("Couldn't get DS register")); 1070 1071 is_x32 = ds == AMD64_LINUX_X32_DS; 1072 1073 if (sizeof (void *) == 4 && is_64bit && !is_x32) 1074 error (_("Can't debug 64-bit process with 32-bit GDB")); 1075 1076 if (have_ptrace_getregset == -1) 1077 { 1078 uint64_t xstateregs[(I386_XSTATE_SSE_SIZE / sizeof (uint64_t))]; 1079 struct iovec iov; 1080 1081 iov.iov_base = xstateregs; 1082 iov.iov_len = sizeof (xstateregs); 1083 1084 /* Check if PTRACE_GETREGSET works. */ 1085 if (ptrace (PTRACE_GETREGSET, tid, 1086 (unsigned int) NT_X86_XSTATE, (long) &iov) < 0) 1087 have_ptrace_getregset = 0; 1088 else 1089 { 1090 have_ptrace_getregset = 1; 1091 1092 /* Get XCR0 from XSAVE extended state. */ 1093 xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET 1094 / sizeof (uint64_t))]; 1095 } 1096 } 1097 1098 /* Check the native XCR0 only if PTRACE_GETREGSET is available. */ 1099 if (have_ptrace_getregset && (xcr0 & I386_XSTATE_ALL_MASK)) 1100 { 1101 switch (xcr0 & I386_XSTATE_ALL_MASK) 1102 { 1103 case I386_XSTATE_MPX_MASK: 1104 if (is_64bit) 1105 { 1106 if (is_x32) 1107 return tdesc_x32_avx_linux; /* No MPX on x32 using AVX. */ 1108 else 1109 return tdesc_amd64_mpx_linux; 1110 } 1111 else 1112 return tdesc_i386_mpx_linux; 1113 case I386_XSTATE_AVX_MASK: 1114 if (is_64bit) 1115 { 1116 if (is_x32) 1117 return tdesc_x32_avx_linux; 1118 else 1119 return tdesc_amd64_avx_linux; 1120 } 1121 else 1122 return tdesc_i386_avx_linux; 1123 default: 1124 if (is_64bit) 1125 { 1126 if (is_x32) 1127 return tdesc_x32_linux; 1128 else 1129 return tdesc_amd64_linux; 1130 } 1131 else 1132 return tdesc_i386_linux; 1133 } 1134 } 1135 else 1136 { 1137 if (is_64bit) 1138 { 1139 if (is_x32) 1140 return tdesc_x32_linux; 1141 else 1142 return tdesc_amd64_linux; 1143 } 1144 else 1145 return tdesc_i386_linux; 1146 } 1147} 1148 1149/* Enable branch tracing. */ 1150 1151static struct btrace_target_info * 1152amd64_linux_enable_btrace (ptid_t ptid) 1153{ 1154 struct btrace_target_info *tinfo; 1155 struct gdbarch *gdbarch; 1156 1157 errno = 0; 1158 tinfo = linux_enable_btrace (ptid); 1159 1160 if (tinfo == NULL) 1161 error (_("Could not enable branch tracing for %s: %s."), 1162 target_pid_to_str (ptid), safe_strerror (errno)); 1163 1164 /* Fill in the size of a pointer in bits. */ 1165 gdbarch = target_thread_architecture (ptid); 1166 tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch); 1167 1168 return tinfo; 1169} 1170 1171/* Disable branch tracing. */ 1172 1173static void 1174amd64_linux_disable_btrace (struct btrace_target_info *tinfo) 1175{ 1176 int errcode = linux_disable_btrace (tinfo); 1177 1178 if (errcode != 0) 1179 error (_("Could not disable branch tracing: %s."), safe_strerror (errcode)); 1180} 1181 1182/* Teardown branch tracing. */ 1183 1184static void 1185amd64_linux_teardown_btrace (struct btrace_target_info *tinfo) 1186{ 1187 /* Ignore errors. */ 1188 linux_disable_btrace (tinfo); 1189} 1190 1191/* Provide a prototype to silence -Wmissing-prototypes. */ 1192void _initialize_amd64_linux_nat (void); 1193 1194void 1195_initialize_amd64_linux_nat (void) 1196{ 1197 struct target_ops *t; 1198 1199 amd64_native_gregset32_reg_offset = amd64_linux_gregset32_reg_offset; 1200 amd64_native_gregset32_num_regs = I386_LINUX_NUM_REGS; 1201 amd64_native_gregset64_reg_offset = amd64_linux_gregset_reg_offset; 1202 amd64_native_gregset64_num_regs = AMD64_LINUX_NUM_REGS; 1203 1204 gdb_assert (ARRAY_SIZE (amd64_linux_gregset32_reg_offset) 1205 == amd64_native_gregset32_num_regs); 1206 1207 /* Fill in the generic GNU/Linux methods. */ 1208 t = linux_target (); 1209 1210 i386_use_watchpoints (t); 1211 1212 i386_dr_low.set_control = amd64_linux_dr_set_control; 1213 i386_dr_low.set_addr = amd64_linux_dr_set_addr; 1214 i386_dr_low.get_addr = amd64_linux_dr_get_addr; 1215 i386_dr_low.get_status = amd64_linux_dr_get_status; 1216 i386_dr_low.get_control = amd64_linux_dr_get_control; 1217 i386_set_debug_register_length (8); 1218 1219 /* Override the GNU/Linux inferior startup hook. */ 1220 super_post_startup_inferior = t->to_post_startup_inferior; 1221 t->to_post_startup_inferior = amd64_linux_child_post_startup_inferior; 1222 1223 /* Add our register access methods. */ 1224 t->to_fetch_registers = amd64_linux_fetch_inferior_registers; 1225 t->to_store_registers = amd64_linux_store_inferior_registers; 1226 1227 t->to_read_description = amd64_linux_read_description; 1228 1229 /* Add btrace methods. */ 1230 t->to_supports_btrace = linux_supports_btrace; 1231 t->to_enable_btrace = amd64_linux_enable_btrace; 1232 t->to_disable_btrace = amd64_linux_disable_btrace; 1233 t->to_teardown_btrace = amd64_linux_teardown_btrace; 1234 t->to_read_btrace = linux_read_btrace; 1235 1236 /* Register the target. */ 1237 linux_nat_add_target (t); 1238 linux_nat_set_new_thread (t, amd64_linux_new_thread); 1239 linux_nat_set_new_fork (t, amd64_linux_new_fork); 1240 linux_nat_set_forget_process (t, i386_forget_process); 1241 linux_nat_set_siginfo_fixup (t, amd64_linux_siginfo_fixup); 1242 linux_nat_set_prepare_to_resume (t, amd64_linux_prepare_to_resume); 1243} 1244