1 /* Native-dependent code for Linux/x86-64.
3 Free Software Foundation, Inc.
4 Contributed by Jiri Smid, SuSE Labs.
6 This file is part of GDB.
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 2 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
28 #include "gdb_assert.h"
29 #include "x86-64-tdep.h"
31 #include <sys/ptrace.h>
32 #include <sys/debugreg.h>
33 #include <sys/syscall.h>
34 #include <sys/procfs.h>
37 x86_64_linux_dr_get (int regnum
)
42 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
43 multi-threaded processes here. For now, pretend there is just
45 tid
= PIDGET (inferior_ptid
);
47 /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
48 ptrace call fails breaks debugging remote targets. The correct
49 way to fix this is to add the hardware breakpoint and watchpoint
50 stuff to the target vectore. For now, just return zero if the
53 value
= ptrace (PT_READ_U
, tid
,
54 offsetof (struct user
, u_debugreg
[regnum
]), 0);
57 perror_with_name ("Couldn't read debug register");
66 x86_64_linux_dr_set (int regnum
, unsigned long value
)
70 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
71 multi-threaded processes here. For now, pretend there is just
73 tid
= PIDGET (inferior_ptid
);
76 ptrace (PT_WRITE_U
, tid
,
77 offsetof (struct user
, u_debugreg
[regnum
]), value
);
79 perror_with_name ("Couldn't write debug register");
83 x86_64_linux_dr_set_control (unsigned long control
)
85 x86_64_linux_dr_set (DR_CONTROL
, control
);
89 x86_64_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
91 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
93 x86_64_linux_dr_set (DR_FIRSTADDR
+ regnum
, addr
);
97 x86_64_linux_dr_reset_addr (int regnum
)
99 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
101 x86_64_linux_dr_set (DR_FIRSTADDR
+ regnum
, 0L);
105 x86_64_linux_dr_get_status (void)
107 return x86_64_linux_dr_get (DR_STATUS
);
111 /* The register sets used in Linux ELF core-dumps are identical to the
112 register sets used by `ptrace'. */
114 #define GETREGS_SUPPLIES(regno) \
115 (0 <= (regno) && (regno) <= 17)
116 #define GETFPREGS_SUPPLIES(regno) \
117 (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
119 #define PTRACE_XFER_TYPE unsigned long
122 /* Transfering the general-purpose registers between GDB, inferiors
125 /* Fill GDB's register array with the general-purpose register values
129 supply_gregset (elf_gregset_t
* gregsetp
)
131 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
134 for (i
= 0; i
< X86_64_NUM_GREGS
; i
++)
135 supply_register (i
, (char *) (regp
+ x86_64_regmap
[i
]));
138 /* Fill register REGNO (if it is a general-purpose register) in
139 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
140 do this for all registers. */
143 fill_gregset (elf_gregset_t
* gregsetp
, int regno
)
145 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
148 for (i
= 0; i
< X86_64_NUM_GREGS
; i
++)
149 if ((regno
== -1 || regno
== i
))
150 *(regp
+ x86_64_regmap
[i
]) =
151 *(elf_greg_t
*) & registers
[REGISTER_BYTE (i
)];
154 /* Fetch all general-purpose registers from process/thread TID and
155 store their values in GDB's register array. */
162 if (ptrace (PTRACE_GETREGS
, tid
, 0, (long) ®s
) < 0)
163 perror_with_name ("Couldn't get registers");
165 supply_gregset (®s
);
168 /* Store all valid general-purpose registers in GDB's register array
169 into the process/thread specified by TID. */
172 store_regs (int tid
, int regno
)
176 if (ptrace (PTRACE_GETREGS
, tid
, 0, (long) ®s
) < 0)
177 perror_with_name ("Couldn't get registers");
179 fill_gregset (®s
, regno
);
181 if (ptrace (PTRACE_SETREGS
, tid
, 0, (long) ®s
) < 0)
182 perror_with_name ("Couldn't write registers");
186 /* Transfering floating-point registers between GDB, inferiors and cores. */
188 /* Fill GDB's register array with the floating-point register values in
192 supply_fpregset (elf_fpregset_t
* fpregsetp
)
194 i387_supply_fxsave ((char *) fpregsetp
);
197 /* Fill register REGNO (if it is a floating-point register) in
198 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
199 do this for all registers. */
202 fill_fpregset (elf_fpregset_t
* fpregsetp
, int regno
)
204 i387_fill_fxsave ((char *) fpregsetp
, regno
);
207 /* Fetch all floating-point registers from process/thread TID and store
208 thier values in GDB's register array. */
211 fetch_fpregs (int tid
)
213 elf_fpregset_t fpregs
;
215 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
216 perror_with_name ("Couldn't get floating point status");
218 supply_fpregset (&fpregs
);
221 /* Store all valid floating-point registers in GDB's register array
222 into the process/thread specified by TID. */
225 store_fpregs (int tid
, int regno
)
227 elf_fpregset_t fpregs
;
229 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
230 perror_with_name ("Couldn't get floating point status");
232 fill_fpregset (&fpregs
, regno
);
234 if (ptrace (PTRACE_SETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
235 perror_with_name ("Couldn't write floating point status");
239 /* Transferring arbitrary registers between GDB and inferior. */
241 /* Fetch register REGNO from the child process. If REGNO is -1, do
242 this for all registers (including the floating point and SSE
246 fetch_inferior_registers (int regno
)
250 /* Linux LWP ID's are process ID's. */
251 if ((tid
= TIDGET (inferior_ptid
)) == 0)
252 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
261 if (GETREGS_SUPPLIES (regno
))
267 if (GETFPREGS_SUPPLIES (regno
))
273 internal_error (__FILE__
, __LINE__
,
274 "Got request for bad register number %d.", regno
);
277 /* Store register REGNO back into the child process. If REGNO is -1,
278 do this for all registers (including the floating point and SSE
281 store_inferior_registers (int regno
)
285 /* Linux LWP ID's are process ID's. */
286 if ((tid
= TIDGET (inferior_ptid
)) == 0)
287 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
291 store_regs (tid
, regno
);
292 store_fpregs (tid
, regno
);
296 if (GETREGS_SUPPLIES (regno
))
298 store_regs (tid
, regno
);
302 if (GETFPREGS_SUPPLIES (regno
))
304 store_fpregs (tid
, regno
);
308 internal_error (__FILE__
, __LINE__
,
309 "Got request to store bad register number %d.", regno
);
313 static const unsigned char linux_syscall
[] = { 0x0f, 0x05 };
315 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
317 /* The system call number is stored in the %rax register. */
318 #define LINUX_SYSCALL_REGNUM 0 /* %rax */
320 /* We are specifically interested in the sigreturn and rt_sigreturn
323 #ifndef SYS_sigreturn
324 #define SYS_sigreturn __NR_sigreturn
326 #ifndef SYS_rt_sigreturn
327 #define SYS_rt_sigreturn __NR_rt_sigreturn
330 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
331 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (152)
332 /* Offset to saved processor registers from <asm/ucontext.h> */
333 #define LINUX_UCONTEXT_SIGCONTEXT_OFFSET (36)
335 /* Resume execution of the inferior process.
336 If STEP is nonzero, single-step it.
337 If SIGNAL is nonzero, give it that signal. */
340 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
342 int pid
= PIDGET (ptid
);
343 int request
= PTRACE_CONT
;
346 /* Resume all threads. */
347 /* I think this only gets used in the non-threaded case, where "resume
348 all threads" and "resume inferior_ptid" are the same. */
349 pid
= PIDGET (inferior_ptid
);
353 CORE_ADDR pc
= read_pc_pid (pid_to_ptid (pid
));
354 unsigned char buf
[LINUX_SYSCALL_LEN
];
356 request
= PTRACE_SINGLESTEP
;
358 /* Returning from a signal trampoline is done by calling a
359 special system call (sigreturn or rt_sigreturn, see
360 i386-linux-tdep.c for more information). This system call
361 restores the registers that were saved when the signal was
362 raised, including %eflags. That means that single-stepping
363 won't work. Instead, we'll have to modify the signal context
364 that's about to be restored, and set the trace flag there. */
366 /* First check if PC is at a system call. */
367 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_SYSCALL_LEN
) == 0
368 && memcmp (buf
, linux_syscall
, LINUX_SYSCALL_LEN
) == 0)
371 read_register_pid (LINUX_SYSCALL_REGNUM
, pid_to_ptid (pid
));
373 /* Then check the system call number. */
374 if (syscall
== SYS_rt_sigreturn
)
376 CORE_ADDR sp
= read_register (SP_REGNUM
);
378 unsigned long int eflags
;
381 sizeof (struct siginfo
) + LINUX_UCONTEXT_SIGCONTEXT_OFFSET
;
383 /* Set the trace flag in the context that's about to be
385 addr
+= LINUX_SIGCONTEXT_EFLAGS_OFFSET
;
386 read_memory (addr
, (char *) &eflags
, 8);
388 write_memory (addr
, (char *) &eflags
, 8);
393 if (ptrace (request
, pid
, 0, target_signal_to_host (signal
)) == -1)
394 perror_with_name ("ptrace");
398 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
399 to debugger memory starting at MYADDR. Copy to inferior if
400 WRITE is nonzero. TARGET is ignored.
402 Returns the length copied, which is either the LEN argument or zero.
403 This xfer function does not do partial moves, since child_ops
404 doesn't allow memory operations to cross below us in the target stack
408 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
409 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
410 struct target_ops
*target
)
413 /* Round starting address down to longword boundary. */
414 register CORE_ADDR addr
= memaddr
& -sizeof (PTRACE_XFER_TYPE
);
415 /* Round ending address up; get number of longwords that makes. */
417 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
418 / sizeof (PTRACE_XFER_TYPE
);
419 /* Allocate buffer of that many longwords. */
420 register PTRACE_XFER_TYPE
*buffer
421 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
425 /* Fill start and end extra bytes of buffer with existing memory data. */
426 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
))
428 /* Need part of initial word -- fetch it. */
429 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
430 (PTRACE_ARG3_TYPE
) addr
, buffer
);
433 if (count
> 1) /* FIXME, avoid if even boundary */
435 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
437 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))),
441 /* Copy data to be written over corresponding part of buffer */
443 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
446 /* Write the entire buffer. */
448 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
451 ptrace (PT_WRITE_D
, PIDGET (inferior_ptid
),
452 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
455 /* Using the appropriate one (I or D) is necessary for
456 Gould NP1, at least. */
458 ptrace (PT_WRITE_I
, PIDGET (inferior_ptid
),
459 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
464 #ifdef CLEAR_INSN_CACHE
470 /* Read all the longwords */
471 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
474 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
475 (PTRACE_ARG3_TYPE
) addr
, buffer
+ i
);
480 /* Copy appropriate bytes out of the buffer. */
482 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
488 /* Interpreting register set info found in core files. */
490 /* Provide registers to GDB from a core file.
492 CORE_REG_SECT points to an array of bytes, which are the contents
493 of a `note' from a core file which BFD thinks might contain
494 register contents. CORE_REG_SIZE is its size.
496 WHICH says which register set corelow suspects this is:
497 0 --- the general-purpose register set, in elf_gregset_t format
498 2 --- the floating-point register set, in elf_fpregset_t format
500 REG_ADDR isn't used on Linux. */
503 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
504 int which
, CORE_ADDR reg_addr
)
506 elf_gregset_t gregset
;
507 elf_fpregset_t fpregset
;
511 if (core_reg_size
!= sizeof (gregset
))
512 warning ("Wrong size gregset in core file.");
515 memcpy (&gregset
, core_reg_sect
, sizeof (gregset
));
516 supply_gregset (&gregset
);
521 if (core_reg_size
!= sizeof (fpregset
))
522 warning ("Wrong size fpregset in core file.");
525 memcpy (&fpregset
, core_reg_sect
, sizeof (fpregset
));
526 supply_fpregset (&fpregset
);
531 /* We've covered all the kinds of registers we know about here,
532 so this must be something we wouldn't know what to do with
533 anyway. Just ignore it. */
538 /* Register that we are able to handle Linux ELF core file formats. */
540 static struct core_fns linux_elf_core_fns
= {
541 bfd_target_elf_flavour
, /* core_flavour */
542 default_check_format
, /* check_format */
543 default_core_sniffer
, /* core_sniffer */
544 fetch_core_registers
, /* core_read_registers */
549 #if !defined (offsetof)
550 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
553 /* Record the value of the debug control register. */
554 static long debug_control_mirror
;
556 /* Record which address associates with which register. */
557 static CORE_ADDR address_lookup
[DR_LASTADDR
- DR_FIRSTADDR
+ 1];
560 _initialize_x86_64_linux_nat (void)
562 add_core_fns (&linux_elf_core_fns
);