1/* Native-dependent code for GNU/Linux i386. 2 3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 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 "defs.h" 22#include "inferior.h" 23#include "gdbcore.h" 24#include "regcache.h" 25#include "target.h" 26#include "linux-nat.h" 27 28#include "gdb_assert.h" 29#include "gdb_string.h" 30#include <sys/ptrace.h> 31#include <sys/user.h> 32#include <sys/procfs.h> 33 34#ifdef HAVE_SYS_REG_H 35#include <sys/reg.h> 36#endif 37 38#ifndef ORIG_EAX 39#define ORIG_EAX -1 40#endif 41 42#ifdef HAVE_SYS_DEBUGREG_H 43#include <sys/debugreg.h> 44#endif 45 46#ifndef DR_FIRSTADDR 47#define DR_FIRSTADDR 0 48#endif 49 50#ifndef DR_LASTADDR 51#define DR_LASTADDR 3 52#endif 53 54#ifndef DR_STATUS 55#define DR_STATUS 6 56#endif 57 58#ifndef DR_CONTROL 59#define DR_CONTROL 7 60#endif 61 62/* Prototypes for supply_gregset etc. */ 63#include "gregset.h" 64 65#include "i387-tdep.h" 66#include "i386-tdep.h" 67#include "i386-linux-tdep.h" 68 69/* Defines ps_err_e, struct ps_prochandle. */ 70#include "gdb_proc_service.h" 71 72 73/* The register sets used in GNU/Linux ELF core-dumps are identical to 74 the register sets in `struct user' that is used for a.out 75 core-dumps, and is also used by `ptrace'. The corresponding types 76 are `elf_gregset_t' for the general-purpose registers (with 77 `elf_greg_t' the type of a single GP register) and `elf_fpregset_t' 78 for the floating-point registers. 79 80 Those types used to be available under the names `gregset_t' and 81 `fpregset_t' too, and this file used those names in the past. But 82 those names are now used for the register sets used in the 83 `mcontext_t' type, and have a different size and layout. */ 84 85/* Mapping between the general-purpose registers in `struct user' 86 format and GDB's register array layout. */ 87static int regmap[] = 88{ 89 EAX, ECX, EDX, EBX, 90 UESP, EBP, ESI, EDI, 91 EIP, EFL, CS, SS, 92 DS, ES, FS, GS, 93 -1, -1, -1, -1, /* st0, st1, st2, st3 */ 94 -1, -1, -1, -1, /* st4, st5, st6, st7 */ 95 -1, -1, -1, -1, /* fctrl, fstat, ftag, fiseg */ 96 -1, -1, -1, -1, /* fioff, foseg, fooff, fop */ 97 -1, -1, -1, -1, /* xmm0, xmm1, xmm2, xmm3 */ 98 -1, -1, -1, -1, /* xmm4, xmm5, xmm6, xmm6 */ 99 -1, /* mxcsr */ 100 ORIG_EAX 101}; 102 103/* Which ptrace request retrieves which registers? 104 These apply to the corresponding SET requests as well. */ 105 106#define GETREGS_SUPPLIES(regno) \ 107 ((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM) 108 109#define GETFPXREGS_SUPPLIES(regno) \ 110 (I386_ST0_REGNUM <= (regno) && (regno) < I386_SSE_NUM_REGS) 111 112/* Does the current host support the GETREGS request? */ 113int have_ptrace_getregs = 114#ifdef HAVE_PTRACE_GETREGS 115 1 116#else 117 0 118#endif 119; 120 121/* Does the current host support the GETFPXREGS request? The header 122 file may or may not define it, and even if it is defined, the 123 kernel will return EIO if it's running on a pre-SSE processor. 124 125 My instinct is to attach this to some architecture- or 126 target-specific data structure, but really, a particular GDB 127 process can only run on top of one kernel at a time. So it's okay 128 for this to be a simple variable. */ 129int have_ptrace_getfpxregs = 130#ifdef HAVE_PTRACE_GETFPXREGS 131 1 132#else 133 0 134#endif 135; 136 137 138/* Accessing registers through the U area, one at a time. */ 139 140/* Fetch one register. */ 141 142static void 143fetch_register (struct regcache *regcache, int regno) 144{ 145 int tid; 146 int val; 147 148 gdb_assert (!have_ptrace_getregs); 149 if (regmap[regno] == -1) 150 { 151 regcache_raw_supply (regcache, regno, NULL); 152 return; 153 } 154 155 /* GNU/Linux LWP ID's are process ID's. */ 156 tid = TIDGET (inferior_ptid); 157 if (tid == 0) 158 tid = PIDGET (inferior_ptid); /* Not a threaded program. */ 159 160 errno = 0; 161 val = ptrace (PTRACE_PEEKUSER, tid, 4 * regmap[regno], 0); 162 if (errno != 0) 163 error (_("Couldn't read register %s (#%d): %s."), 164 gdbarch_register_name (current_gdbarch, regno), 165 regno, safe_strerror (errno)); 166 167 regcache_raw_supply (regcache, regno, &val); 168} 169 170/* Store one register. */ 171 172static void 173store_register (const struct regcache *regcache, int regno) 174{ 175 int tid; 176 int val; 177 178 gdb_assert (!have_ptrace_getregs); 179 if (regmap[regno] == -1) 180 return; 181 182 /* GNU/Linux LWP ID's are process ID's. */ 183 tid = TIDGET (inferior_ptid); 184 if (tid == 0) 185 tid = PIDGET (inferior_ptid); /* Not a threaded program. */ 186 187 errno = 0; 188 regcache_raw_collect (regcache, regno, &val); 189 ptrace (PTRACE_POKEUSER, tid, 4 * regmap[regno], val); 190 if (errno != 0) 191 error (_("Couldn't write register %s (#%d): %s."), 192 gdbarch_register_name (current_gdbarch, regno), 193 regno, safe_strerror (errno)); 194} 195 196 197/* Transfering the general-purpose registers between GDB, inferiors 198 and core files. */ 199 200/* Fill GDB's register array with the general-purpose register values 201 in *GREGSETP. */ 202 203void 204supply_gregset (struct regcache *regcache, const elf_gregset_t *gregsetp) 205{ 206 const elf_greg_t *regp = (const elf_greg_t *) gregsetp; 207 int i; 208 209 for (i = 0; i < I386_NUM_GREGS; i++) 210 regcache_raw_supply (regcache, i, regp + regmap[i]); 211 212 if (I386_LINUX_ORIG_EAX_REGNUM < gdbarch_num_regs (current_gdbarch)) 213 regcache_raw_supply (regcache, I386_LINUX_ORIG_EAX_REGNUM, 214 regp + ORIG_EAX); 215} 216 217/* Fill register REGNO (if it is a general-purpose register) in 218 *GREGSETPS with the value in GDB's register array. If REGNO is -1, 219 do this for all registers. */ 220 221void 222fill_gregset (const struct regcache *regcache, 223 elf_gregset_t *gregsetp, int regno) 224{ 225 elf_greg_t *regp = (elf_greg_t *) gregsetp; 226 int i; 227 228 for (i = 0; i < I386_NUM_GREGS; i++) 229 if (regno == -1 || regno == i) 230 regcache_raw_collect (regcache, i, regp + regmap[i]); 231 232 if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM) 233 && I386_LINUX_ORIG_EAX_REGNUM < gdbarch_num_regs (current_gdbarch)) 234 regcache_raw_collect (regcache, I386_LINUX_ORIG_EAX_REGNUM, 235 regp + ORIG_EAX); 236} 237 238#ifdef HAVE_PTRACE_GETREGS 239 240/* Fetch all general-purpose registers from process/thread TID and 241 store their values in GDB's register array. */ 242 243static void 244fetch_regs (struct regcache *regcache, int tid) 245{ 246 elf_gregset_t regs; 247 elf_gregset_t *regs_p = ®s; 248 249 if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0) 250 { 251 if (errno == EIO) 252 { 253 /* The kernel we're running on doesn't support the GETREGS 254 request. Reset `have_ptrace_getregs'. */ 255 have_ptrace_getregs = 0; 256 return; 257 } 258 259 perror_with_name (_("Couldn't get registers")); 260 } 261 262 supply_gregset (regcache, (const elf_gregset_t *) regs_p); 263} 264 265/* Store all valid general-purpose registers in GDB's register array 266 into the process/thread specified by TID. */ 267 268static void 269store_regs (const struct regcache *regcache, int tid, int regno) 270{ 271 elf_gregset_t regs; 272 273 if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0) 274 perror_with_name (_("Couldn't get registers")); 275 276 fill_gregset (regcache, ®s, regno); 277 278 if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0) 279 perror_with_name (_("Couldn't write registers")); 280} 281 282#else 283 284static void fetch_regs (struct regcache *regcache, int tid) {} 285static void store_regs (const struct regcache *regcache, int tid, int regno) {} 286 287#endif 288 289 290/* Transfering floating-point registers between GDB, inferiors and cores. */ 291 292/* Fill GDB's register array with the floating-point register values in 293 *FPREGSETP. */ 294 295void 296supply_fpregset (struct regcache *regcache, const elf_fpregset_t *fpregsetp) 297{ 298 i387_supply_fsave (regcache, -1, fpregsetp); 299} 300 301/* Fill register REGNO (if it is a floating-point register) in 302 *FPREGSETP with the value in GDB's register array. If REGNO is -1, 303 do this for all registers. */ 304 305void 306fill_fpregset (const struct regcache *regcache, 307 elf_fpregset_t *fpregsetp, int regno) 308{ 309 i387_collect_fsave (regcache, regno, fpregsetp); 310} 311 312#ifdef HAVE_PTRACE_GETREGS 313 314/* Fetch all floating-point registers from process/thread TID and store 315 thier values in GDB's register array. */ 316 317static void 318fetch_fpregs (struct regcache *regcache, int tid) 319{ 320 elf_fpregset_t fpregs; 321 322 if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0) 323 perror_with_name (_("Couldn't get floating point status")); 324 325 supply_fpregset (regcache, (const elf_fpregset_t *) &fpregs); 326} 327 328/* Store all valid floating-point registers in GDB's register array 329 into the process/thread specified by TID. */ 330 331static void 332store_fpregs (const struct regcache *regcache, int tid, int regno) 333{ 334 elf_fpregset_t fpregs; 335 336 if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0) 337 perror_with_name (_("Couldn't get floating point status")); 338 339 fill_fpregset (regcache, &fpregs, regno); 340 341 if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0) 342 perror_with_name (_("Couldn't write floating point status")); 343} 344 345#else 346 347static void fetch_fpregs (struct regcache *regcache, int tid) {} 348static void store_fpregs (const struct regcache *regcache, int tid, int regno) {} 349 350#endif 351 352 353/* Transfering floating-point and SSE registers to and from GDB. */ 354 355#ifdef HAVE_PTRACE_GETFPXREGS 356 357/* Fill GDB's register array with the floating-point and SSE register 358 values in *FPXREGSETP. */ 359 360void 361supply_fpxregset (struct regcache *regcache, 362 const elf_fpxregset_t *fpxregsetp) 363{ 364 i387_supply_fxsave (regcache, -1, fpxregsetp); 365} 366 367/* Fill register REGNO (if it is a floating-point or SSE register) in 368 *FPXREGSETP with the value in GDB's register array. If REGNO is 369 -1, do this for all registers. */ 370 371void 372fill_fpxregset (const struct regcache *regcache, 373 elf_fpxregset_t *fpxregsetp, int regno) 374{ 375 i387_collect_fxsave (regcache, regno, fpxregsetp); 376} 377 378/* Fetch all registers covered by the PTRACE_GETFPXREGS request from 379 process/thread TID and store their values in GDB's register array. 380 Return non-zero if successful, zero otherwise. */ 381 382static int 383fetch_fpxregs (struct regcache *regcache, int tid) 384{ 385 elf_fpxregset_t fpxregs; 386 387 if (! have_ptrace_getfpxregs) 388 return 0; 389 390 if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0) 391 { 392 if (errno == EIO) 393 { 394 have_ptrace_getfpxregs = 0; 395 return 0; 396 } 397 398 perror_with_name (_("Couldn't read floating-point and SSE registers")); 399 } 400 401 supply_fpxregset (regcache, (const elf_fpxregset_t *) &fpxregs); 402 return 1; 403} 404 405/* Store all valid registers in GDB's register array covered by the 406 PTRACE_SETFPXREGS request into the process/thread specified by TID. 407 Return non-zero if successful, zero otherwise. */ 408 409static int 410store_fpxregs (const struct regcache *regcache, int tid, int regno) 411{ 412 elf_fpxregset_t fpxregs; 413 414 if (! have_ptrace_getfpxregs) 415 return 0; 416 417 if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1) 418 { 419 if (errno == EIO) 420 { 421 have_ptrace_getfpxregs = 0; 422 return 0; 423 } 424 425 perror_with_name (_("Couldn't read floating-point and SSE registers")); 426 } 427 428 fill_fpxregset (regcache, &fpxregs, regno); 429 430 if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1) 431 perror_with_name (_("Couldn't write floating-point and SSE registers")); 432 433 return 1; 434} 435 436#else 437 438static int fetch_fpxregs (struct regcache *regcache, int tid) { return 0; } 439static int store_fpxregs (const struct regcache *regcache, int tid, int regno) { return 0; } 440 441#endif /* HAVE_PTRACE_GETFPXREGS */ 442 443 444/* Transferring arbitrary registers between GDB and inferior. */ 445 446/* Fetch register REGNO from the child process. If REGNO is -1, do 447 this for all registers (including the floating point and SSE 448 registers). */ 449 450static void 451i386_linux_fetch_inferior_registers (struct regcache *regcache, int regno) 452{ 453 int tid; 454 455 /* Use the old method of peeking around in `struct user' if the 456 GETREGS request isn't available. */ 457 if (!have_ptrace_getregs) 458 { 459 int i; 460 461 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++) 462 if (regno == -1 || regno == i) 463 fetch_register (regcache, i); 464 465 return; 466 } 467 468 /* GNU/Linux LWP ID's are process ID's. */ 469 tid = TIDGET (inferior_ptid); 470 if (tid == 0) 471 tid = PIDGET (inferior_ptid); /* Not a threaded program. */ 472 473 /* Use the PTRACE_GETFPXREGS request whenever possible, since it 474 transfers more registers in one system call, and we'll cache the 475 results. But remember that fetch_fpxregs can fail, and return 476 zero. */ 477 if (regno == -1) 478 { 479 fetch_regs (regcache, tid); 480 481 /* The call above might reset `have_ptrace_getregs'. */ 482 if (!have_ptrace_getregs) 483 { 484 i386_linux_fetch_inferior_registers (regcache, regno); 485 return; 486 } 487 488 if (fetch_fpxregs (regcache, tid)) 489 return; 490 fetch_fpregs (regcache, tid); 491 return; 492 } 493 494 if (GETREGS_SUPPLIES (regno)) 495 { 496 fetch_regs (regcache, tid); 497 return; 498 } 499 500 if (GETFPXREGS_SUPPLIES (regno)) 501 { 502 if (fetch_fpxregs (regcache, tid)) 503 return; 504 505 /* Either our processor or our kernel doesn't support the SSE 506 registers, so read the FP registers in the traditional way, 507 and fill the SSE registers with dummy values. It would be 508 more graceful to handle differences in the register set using 509 gdbarch. Until then, this will at least make things work 510 plausibly. */ 511 fetch_fpregs (regcache, tid); 512 return; 513 } 514 515 internal_error (__FILE__, __LINE__, 516 _("Got request for bad register number %d."), regno); 517} 518 519/* Store register REGNO back into the child process. If REGNO is -1, 520 do this for all registers (including the floating point and SSE 521 registers). */ 522static void 523i386_linux_store_inferior_registers (struct regcache *regcache, int regno) 524{ 525 int tid; 526 527 /* Use the old method of poking around in `struct user' if the 528 SETREGS request isn't available. */ 529 if (!have_ptrace_getregs) 530 { 531 int i; 532 533 for (i = 0; i < gdbarch_num_regs (current_gdbarch); i++) 534 if (regno == -1 || regno == i) 535 store_register (regcache, i); 536 537 return; 538 } 539 540 /* GNU/Linux LWP ID's are process ID's. */ 541 tid = TIDGET (inferior_ptid); 542 if (tid == 0) 543 tid = PIDGET (inferior_ptid); /* Not a threaded program. */ 544 545 /* Use the PTRACE_SETFPXREGS requests whenever possible, since it 546 transfers more registers in one system call. But remember that 547 store_fpxregs can fail, and return zero. */ 548 if (regno == -1) 549 { 550 store_regs (regcache, tid, regno); 551 if (store_fpxregs (regcache, tid, regno)) 552 return; 553 store_fpregs (regcache, tid, regno); 554 return; 555 } 556 557 if (GETREGS_SUPPLIES (regno)) 558 { 559 store_regs (regcache, tid, regno); 560 return; 561 } 562 563 if (GETFPXREGS_SUPPLIES (regno)) 564 { 565 if (store_fpxregs (regcache, tid, regno)) 566 return; 567 568 /* Either our processor or our kernel doesn't support the SSE 569 registers, so just write the FP registers in the traditional 570 way. */ 571 store_fpregs (regcache, tid, regno); 572 return; 573 } 574 575 internal_error (__FILE__, __LINE__, 576 _("Got request to store bad register number %d."), regno); 577} 578 579 580/* Support for debug registers. */ 581 582static unsigned long 583i386_linux_dr_get (int regnum) 584{ 585 int tid; 586 unsigned long value; 587 588 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with 589 multi-threaded processes here. For now, pretend there is just 590 one thread. */ 591 tid = PIDGET (inferior_ptid); 592 593 /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the 594 ptrace call fails breaks debugging remote targets. The correct 595 way to fix this is to add the hardware breakpoint and watchpoint 596 stuff to the target vector. For now, just return zero if the 597 ptrace call fails. */ 598 errno = 0; 599 value = ptrace (PTRACE_PEEKUSER, tid, 600 offsetof (struct user, u_debugreg[regnum]), 0); 601 if (errno != 0) 602#if 0 603 perror_with_name (_("Couldn't read debug register")); 604#else 605 return 0; 606#endif 607 608 return value; 609} 610 611static void 612i386_linux_dr_set (int regnum, unsigned long value) 613{ 614 int tid; 615 616 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with 617 multi-threaded processes here. For now, pretend there is just 618 one thread. */ 619 tid = PIDGET (inferior_ptid); 620 621 errno = 0; 622 ptrace (PTRACE_POKEUSER, tid, 623 offsetof (struct user, u_debugreg[regnum]), value); 624 if (errno != 0) 625 perror_with_name (_("Couldn't write debug register")); 626} 627 628void 629i386_linux_dr_set_control (unsigned long control) 630{ 631 i386_linux_dr_set (DR_CONTROL, control); 632} 633 634void 635i386_linux_dr_set_addr (int regnum, CORE_ADDR addr) 636{ 637 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); 638 639 i386_linux_dr_set (DR_FIRSTADDR + regnum, addr); 640} 641 642void 643i386_linux_dr_reset_addr (int regnum) 644{ 645 gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); 646 647 i386_linux_dr_set (DR_FIRSTADDR + regnum, 0L); 648} 649 650unsigned long 651i386_linux_dr_get_status (void) 652{ 653 return i386_linux_dr_get (DR_STATUS); 654} 655 656 657/* Called by libthread_db. Returns a pointer to the thread local 658 storage (or its descriptor). */ 659 660ps_err_e 661ps_get_thread_area (const struct ps_prochandle *ph, 662 lwpid_t lwpid, int idx, void **base) 663{ 664 /* NOTE: cagney/2003-08-26: The definition of this buffer is found 665 in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x 666 4 byte integers in size: `entry_number', `base_addr', `limit', 667 and a bunch of status bits. 668 669 The values returned by this ptrace call should be part of the 670 regcache buffer, and ps_get_thread_area should channel its 671 request through the regcache. That way remote targets could 672 provide the value using the remote protocol and not this direct 673 call. 674 675 Is this function needed? I'm guessing that the `base' is the 676 address of a a descriptor that libthread_db uses to find the 677 thread local address base that GDB needs. Perhaps that 678 descriptor is defined by the ABI. Anyway, given that 679 libthread_db calls this function without prompting (gdb 680 requesting tls base) I guess it needs info in there anyway. */ 681 unsigned int desc[4]; 682 gdb_assert (sizeof (int) == 4); 683 684#ifndef PTRACE_GET_THREAD_AREA 685#define PTRACE_GET_THREAD_AREA 25 686#endif 687 688 if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, 689 (void *) idx, (unsigned long) &desc) < 0) 690 return PS_ERR; 691 692 *(int *)base = desc[1]; 693 return PS_OK; 694} 695 696 697/* The instruction for a GNU/Linux system call is: 698 int $0x80 699 or 0xcd 0x80. */ 700 701static const unsigned char linux_syscall[] = { 0xcd, 0x80 }; 702 703#define LINUX_SYSCALL_LEN (sizeof linux_syscall) 704 705/* The system call number is stored in the %eax register. */ 706#define LINUX_SYSCALL_REGNUM I386_EAX_REGNUM 707 708/* We are specifically interested in the sigreturn and rt_sigreturn 709 system calls. */ 710 711#ifndef SYS_sigreturn 712#define SYS_sigreturn 0x77 713#endif 714#ifndef SYS_rt_sigreturn 715#define SYS_rt_sigreturn 0xad 716#endif 717 718/* Offset to saved processor flags, from <asm/sigcontext.h>. */ 719#define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64) 720 721/* Resume execution of the inferior process. 722 If STEP is nonzero, single-step it. 723 If SIGNAL is nonzero, give it that signal. */ 724 725static void 726i386_linux_resume (ptid_t ptid, int step, enum target_signal signal) 727{ 728 int pid = PIDGET (ptid); 729 730 int request = PTRACE_CONT; 731 732 if (pid == -1) 733 /* Resume all threads. */ 734 /* I think this only gets used in the non-threaded case, where "resume 735 all threads" and "resume inferior_ptid" are the same. */ 736 pid = PIDGET (inferior_ptid); 737 738 if (step) 739 { 740 struct regcache *regcache = get_thread_regcache (pid_to_ptid (pid)); 741 ULONGEST pc; 742 gdb_byte buf[LINUX_SYSCALL_LEN]; 743 744 request = PTRACE_SINGLESTEP; 745 746 regcache_cooked_read_unsigned (regcache, 747 gdbarch_pc_regnum (current_gdbarch), &pc); 748 749 /* Returning from a signal trampoline is done by calling a 750 special system call (sigreturn or rt_sigreturn, see 751 i386-linux-tdep.c for more information). This system call 752 restores the registers that were saved when the signal was 753 raised, including %eflags. That means that single-stepping 754 won't work. Instead, we'll have to modify the signal context 755 that's about to be restored, and set the trace flag there. */ 756 757 /* First check if PC is at a system call. */ 758 if (read_memory_nobpt (pc, buf, LINUX_SYSCALL_LEN) == 0 759 && memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0) 760 { 761 ULONGEST syscall; 762 regcache_cooked_read_unsigned (regcache, 763 LINUX_SYSCALL_REGNUM, &syscall); 764 765 /* Then check the system call number. */ 766 if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn) 767 { 768 ULONGEST sp, addr; 769 unsigned long int eflags; 770 771 regcache_cooked_read_unsigned (regcache, I386_ESP_REGNUM, &sp); 772 if (syscall == SYS_rt_sigreturn) 773 addr = read_memory_integer (sp + 8, 4) + 20; 774 else 775 addr = sp; 776 777 /* Set the trace flag in the context that's about to be 778 restored. */ 779 addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET; 780 read_memory (addr, (gdb_byte *) &eflags, 4); 781 eflags |= 0x0100; 782 write_memory (addr, (gdb_byte *) &eflags, 4); 783 } 784 } 785 } 786 787 if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1) 788 perror_with_name (("ptrace")); 789} 790 791static void (*super_post_startup_inferior) (ptid_t ptid); 792 793static void 794i386_linux_child_post_startup_inferior (ptid_t ptid) 795{ 796 i386_cleanup_dregs (); 797 super_post_startup_inferior (ptid); 798} 799 800void 801_initialize_i386_linux_nat (void) 802{ 803 struct target_ops *t; 804 805 /* Fill in the generic GNU/Linux methods. */ 806 t = linux_target (); 807 808 /* Override the default ptrace resume method. */ 809 t->to_resume = i386_linux_resume; 810 811 /* Override the GNU/Linux inferior startup hook. */ 812 super_post_startup_inferior = t->to_post_startup_inferior; 813 t->to_post_startup_inferior = i386_linux_child_post_startup_inferior; 814 815 /* Add our register access methods. */ 816 t->to_fetch_registers = i386_linux_fetch_inferior_registers; 817 t->to_store_registers = i386_linux_store_inferior_registers; 818 819 /* Register the target. */ 820 linux_nat_add_target (t); 821} 822