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 read_register_gen (i
, regp
+ x86_64_regmap
[i
]);
153 /* Fetch all general-purpose registers from process/thread TID and
154 store their values in GDB's register array. */
161 if (ptrace (PTRACE_GETREGS
, tid
, 0, (long) ®s
) < 0)
162 perror_with_name ("Couldn't get registers");
164 supply_gregset (®s
);
167 /* Store all valid general-purpose registers in GDB's register array
168 into the process/thread specified by TID. */
171 store_regs (int tid
, int regno
)
175 if (ptrace (PTRACE_GETREGS
, tid
, 0, (long) ®s
) < 0)
176 perror_with_name ("Couldn't get registers");
178 fill_gregset (®s
, regno
);
180 if (ptrace (PTRACE_SETREGS
, tid
, 0, (long) ®s
) < 0)
181 perror_with_name ("Couldn't write registers");
185 /* Transfering floating-point registers between GDB, inferiors and cores. */
187 /* Fill GDB's register array with the floating-point register values in
191 supply_fpregset (elf_fpregset_t
* fpregsetp
)
193 i387_supply_fxsave ((char *) fpregsetp
);
196 /* Fill register REGNO (if it is a floating-point register) in
197 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
198 do this for all registers. */
201 fill_fpregset (elf_fpregset_t
* fpregsetp
, int regno
)
203 i387_fill_fxsave ((char *) fpregsetp
, regno
);
206 /* Fetch all floating-point registers from process/thread TID and store
207 thier values in GDB's register array. */
210 fetch_fpregs (int tid
)
212 elf_fpregset_t fpregs
;
214 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
215 perror_with_name ("Couldn't get floating point status");
217 supply_fpregset (&fpregs
);
220 /* Store all valid floating-point registers in GDB's register array
221 into the process/thread specified by TID. */
224 store_fpregs (int tid
, int regno
)
226 elf_fpregset_t fpregs
;
228 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
229 perror_with_name ("Couldn't get floating point status");
231 fill_fpregset (&fpregs
, regno
);
233 if (ptrace (PTRACE_SETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
234 perror_with_name ("Couldn't write floating point status");
238 /* Transferring arbitrary registers between GDB and inferior. */
240 /* Fetch register REGNO from the child process. If REGNO is -1, do
241 this for all registers (including the floating point and SSE
245 fetch_inferior_registers (int regno
)
249 /* Linux LWP ID's are process ID's. */
250 if ((tid
= TIDGET (inferior_ptid
)) == 0)
251 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
260 if (GETREGS_SUPPLIES (regno
))
266 if (GETFPREGS_SUPPLIES (regno
))
272 internal_error (__FILE__
, __LINE__
,
273 "Got request for bad register number %d.", regno
);
276 /* Store register REGNO back into the child process. If REGNO is -1,
277 do this for all registers (including the floating point and SSE
280 store_inferior_registers (int regno
)
284 /* Linux LWP ID's are process ID's. */
285 if ((tid
= TIDGET (inferior_ptid
)) == 0)
286 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
290 store_regs (tid
, regno
);
291 store_fpregs (tid
, regno
);
295 if (GETREGS_SUPPLIES (regno
))
297 store_regs (tid
, regno
);
301 if (GETFPREGS_SUPPLIES (regno
))
303 store_fpregs (tid
, regno
);
307 internal_error (__FILE__
, __LINE__
,
308 "Got request to store bad register number %d.", regno
);
312 static const unsigned char linux_syscall
[] = { 0x0f, 0x05 };
314 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
316 /* The system call number is stored in the %rax register. */
317 #define LINUX_SYSCALL_REGNUM 0 /* %rax */
319 /* We are specifically interested in the sigreturn and rt_sigreturn
322 #ifndef SYS_sigreturn
323 #define SYS_sigreturn __NR_sigreturn
325 #ifndef SYS_rt_sigreturn
326 #define SYS_rt_sigreturn __NR_rt_sigreturn
329 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
330 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (152)
331 /* Offset to saved processor registers from <asm/ucontext.h> */
332 #define LINUX_UCONTEXT_SIGCONTEXT_OFFSET (36)
334 /* Resume execution of the inferior process.
335 If STEP is nonzero, single-step it.
336 If SIGNAL is nonzero, give it that signal. */
339 child_resume (ptid_t ptid
, int step
, enum target_signal signal
)
341 int pid
= PIDGET (ptid
);
342 int request
= PTRACE_CONT
;
345 /* Resume all threads. */
346 /* I think this only gets used in the non-threaded case, where "resume
347 all threads" and "resume inferior_ptid" are the same. */
348 pid
= PIDGET (inferior_ptid
);
352 CORE_ADDR pc
= read_pc_pid (pid_to_ptid (pid
));
353 unsigned char buf
[LINUX_SYSCALL_LEN
];
355 request
= PTRACE_SINGLESTEP
;
357 /* Returning from a signal trampoline is done by calling a
358 special system call (sigreturn or rt_sigreturn, see
359 i386-linux-tdep.c for more information). This system call
360 restores the registers that were saved when the signal was
361 raised, including %eflags. That means that single-stepping
362 won't work. Instead, we'll have to modify the signal context
363 that's about to be restored, and set the trace flag there. */
365 /* First check if PC is at a system call. */
366 if (read_memory_nobpt (pc
, (char *) buf
, LINUX_SYSCALL_LEN
) == 0
367 && memcmp (buf
, linux_syscall
, LINUX_SYSCALL_LEN
) == 0)
370 read_register_pid (LINUX_SYSCALL_REGNUM
, pid_to_ptid (pid
));
372 /* Then check the system call number. */
373 if (syscall
== SYS_rt_sigreturn
)
375 CORE_ADDR sp
= read_register (SP_REGNUM
);
377 unsigned long int eflags
;
380 sizeof (struct siginfo
) + LINUX_UCONTEXT_SIGCONTEXT_OFFSET
;
382 /* Set the trace flag in the context that's about to be
384 addr
+= LINUX_SIGCONTEXT_EFLAGS_OFFSET
;
385 read_memory (addr
, (char *) &eflags
, 8);
387 write_memory (addr
, (char *) &eflags
, 8);
392 if (ptrace (request
, pid
, 0, target_signal_to_host (signal
)) == -1)
393 perror_with_name ("ptrace");
397 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
398 to debugger memory starting at MYADDR. Copy to inferior if
399 WRITE is nonzero. TARGET is ignored.
401 Returns the length copied, which is either the LEN argument or zero.
402 This xfer function does not do partial moves, since child_ops
403 doesn't allow memory operations to cross below us in the target stack
407 child_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
408 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
409 struct target_ops
*target
)
412 /* Round starting address down to longword boundary. */
413 register CORE_ADDR addr
= memaddr
& -sizeof (PTRACE_XFER_TYPE
);
414 /* Round ending address up; get number of longwords that makes. */
416 = (((memaddr
+ len
) - addr
) + sizeof (PTRACE_XFER_TYPE
) - 1)
417 / sizeof (PTRACE_XFER_TYPE
);
418 /* Allocate buffer of that many longwords. */
419 /* FIXME (alloca): This code, cloned from infptrace.c, is unsafe
420 because it uses alloca to allocate a buffer of arbitrary size.
421 For very large xfers, this could crash GDB's stack. */
422 register PTRACE_XFER_TYPE
*buffer
423 = (PTRACE_XFER_TYPE
*) alloca (count
* sizeof (PTRACE_XFER_TYPE
));
427 /* Fill start and end extra bytes of buffer with existing memory data. */
428 if (addr
!= memaddr
|| len
< (int) sizeof (PTRACE_XFER_TYPE
))
430 /* Need part of initial word -- fetch it. */
431 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
432 (PTRACE_ARG3_TYPE
) addr
, buffer
);
435 if (count
> 1) /* FIXME, avoid if even boundary */
437 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
439 (addr
+ (count
- 1) * sizeof (PTRACE_XFER_TYPE
))),
443 /* Copy data to be written over corresponding part of buffer */
445 memcpy ((char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
448 /* Write the entire buffer. */
450 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
453 ptrace (PT_WRITE_D
, PIDGET (inferior_ptid
),
454 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
457 /* Using the appropriate one (I or D) is necessary for
458 Gould NP1, at least. */
460 ptrace (PT_WRITE_I
, PIDGET (inferior_ptid
),
461 (PTRACE_ARG3_TYPE
) addr
, buffer
[i
]);
466 #ifdef CLEAR_INSN_CACHE
472 /* Read all the longwords */
473 for (i
= 0; i
< count
; i
++, addr
+= sizeof (PTRACE_XFER_TYPE
))
476 ptrace (PT_READ_I
, PIDGET (inferior_ptid
),
477 (PTRACE_ARG3_TYPE
) addr
, buffer
+ i
);
482 /* Copy appropriate bytes out of the buffer. */
484 (char *) buffer
+ (memaddr
& (sizeof (PTRACE_XFER_TYPE
) - 1)),
490 /* Interpreting register set info found in core files. */
492 /* Provide registers to GDB from a core file.
494 CORE_REG_SECT points to an array of bytes, which are the contents
495 of a `note' from a core file which BFD thinks might contain
496 register contents. CORE_REG_SIZE is its size.
498 WHICH says which register set corelow suspects this is:
499 0 --- the general-purpose register set, in elf_gregset_t format
500 2 --- the floating-point register set, in elf_fpregset_t format
502 REG_ADDR isn't used on Linux. */
505 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
506 int which
, CORE_ADDR reg_addr
)
508 elf_gregset_t gregset
;
509 elf_fpregset_t fpregset
;
513 if (core_reg_size
!= sizeof (gregset
))
514 warning ("Wrong size gregset in core file.");
517 memcpy (&gregset
, core_reg_sect
, sizeof (gregset
));
518 supply_gregset (&gregset
);
523 if (core_reg_size
!= sizeof (fpregset
))
524 warning ("Wrong size fpregset in core file.");
527 memcpy (&fpregset
, core_reg_sect
, sizeof (fpregset
));
528 supply_fpregset (&fpregset
);
533 /* We've covered all the kinds of registers we know about here,
534 so this must be something we wouldn't know what to do with
535 anyway. Just ignore it. */
540 /* Register that we are able to handle Linux ELF core file formats. */
542 static struct core_fns linux_elf_core_fns
= {
543 bfd_target_elf_flavour
, /* core_flavour */
544 default_check_format
, /* check_format */
545 default_core_sniffer
, /* core_sniffer */
546 fetch_core_registers
, /* core_read_registers */
551 #if !defined (offsetof)
552 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
555 /* Record the value of the debug control register. */
556 static long debug_control_mirror
;
558 /* Record which address associates with which register. */
559 static CORE_ADDR address_lookup
[DR_LASTADDR
- DR_FIRSTADDR
+ 1];
562 _initialize_x86_64_linux_nat (void)
564 add_core_fns (&linux_elf_core_fns
);