1 /* Native-dependent code for GNU/Linux x86-64.
3 Copyright 2001, 2002 Free Software Foundation, Inc.
5 Contributed by Jiri Smid, SuSE Labs.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 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 /* Mapping between the general-purpose registers in `struct user'
38 format and GDB's register array layout. */
40 static int x86_64_regmap
[] = {
50 x86_64_linux_dr_get (int regnum
)
55 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
56 multi-threaded processes here. For now, pretend there is just
58 tid
= PIDGET (inferior_ptid
);
60 /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the
61 ptrace call fails breaks debugging remote targets. The correct
62 way to fix this is to add the hardware breakpoint and watchpoint
63 stuff to the target vectore. For now, just return zero if the
66 value
= ptrace (PT_READ_U
, tid
,
67 offsetof (struct user
, u_debugreg
[regnum
]), 0);
70 perror_with_name ("Couldn't read debug register");
79 x86_64_linux_dr_set (int regnum
, unsigned long value
)
83 /* FIXME: kettenis/2001-01-29: It's not clear what we should do with
84 multi-threaded processes here. For now, pretend there is just
86 tid
= PIDGET (inferior_ptid
);
89 ptrace (PT_WRITE_U
, tid
, offsetof (struct user
, u_debugreg
[regnum
]), value
);
91 perror_with_name ("Couldn't write debug register");
95 x86_64_linux_dr_set_control (unsigned long control
)
97 x86_64_linux_dr_set (DR_CONTROL
, control
);
101 x86_64_linux_dr_set_addr (int regnum
, CORE_ADDR addr
)
103 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
105 x86_64_linux_dr_set (DR_FIRSTADDR
+ regnum
, addr
);
109 x86_64_linux_dr_reset_addr (int regnum
)
111 gdb_assert (regnum
>= 0 && regnum
<= DR_LASTADDR
- DR_FIRSTADDR
);
113 x86_64_linux_dr_set (DR_FIRSTADDR
+ regnum
, 0L);
117 x86_64_linux_dr_get_status (void)
119 return x86_64_linux_dr_get (DR_STATUS
);
123 /* The register sets used in GNU/Linux ELF core-dumps are identical to
124 the register sets used by `ptrace'. */
126 #define GETREGS_SUPPLIES(regno) \
127 (0 <= (regno) && (regno) < x86_64_num_gregs)
128 #define GETFPREGS_SUPPLIES(regno) \
129 (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
132 /* Transfering the general-purpose registers between GDB, inferiors
135 /* Fill GDB's register array with the general-purpose register values
139 supply_gregset (elf_gregset_t
* gregsetp
)
141 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
144 for (i
= 0; i
< x86_64_num_gregs
; i
++)
145 supply_register (i
, (char *) (regp
+ x86_64_regmap
[i
]));
148 /* Fill register REGNO (if it is a general-purpose register) in
149 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
150 do this for all registers. */
153 fill_gregset (elf_gregset_t
* gregsetp
, int regno
)
155 elf_greg_t
*regp
= (elf_greg_t
*) gregsetp
;
158 for (i
= 0; i
< x86_64_num_gregs
; i
++)
159 if ((regno
== -1 || regno
== i
))
160 read_register_gen (i
, (char *) (regp
+ x86_64_regmap
[i
]));
163 /* Fetch all general-purpose registers from process/thread TID and
164 store their values in GDB's register array. */
171 if (ptrace (PTRACE_GETREGS
, tid
, 0, (long) ®s
) < 0)
172 perror_with_name ("Couldn't get registers");
174 supply_gregset (®s
);
177 /* Store all valid general-purpose registers in GDB's register array
178 into the process/thread specified by TID. */
181 store_regs (int tid
, int regno
)
185 if (ptrace (PTRACE_GETREGS
, tid
, 0, (long) ®s
) < 0)
186 perror_with_name ("Couldn't get registers");
188 fill_gregset (®s
, regno
);
190 if (ptrace (PTRACE_SETREGS
, tid
, 0, (long) ®s
) < 0)
191 perror_with_name ("Couldn't write registers");
195 /* Transfering floating-point registers between GDB, inferiors and cores. */
198 x86_64_fxsave_offset (elf_fpregset_t
* fxsave
, int regnum
)
200 const char *reg_name
;
203 gdb_assert (x86_64_num_gregs
- 1 < regnum
&& regnum
< x86_64_num_regs
);
205 reg_name
= x86_64_register_name (regnum
);
207 if (reg_name
[0] == 's' && reg_name
[1] == 't')
209 reg_index
= reg_name
[2] - '0';
210 return &fxsave
->st_space
[reg_index
* 2];
213 if (reg_name
[0] == 'x' && reg_name
[1] == 'm' && reg_name
[2] == 'm')
215 reg_index
= reg_name
[3] - '0';
216 return &fxsave
->xmm_space
[reg_index
* 4];
219 if (strcmp (reg_name
, "mxcsr") == 0)
220 return &fxsave
->mxcsr
;
225 /* Fill GDB's register array with the floating-point and SSE register
226 values in *FXSAVE. This function masks off any of the reserved
230 supply_fpregset (elf_fpregset_t
* fxsave
)
232 int i
, reg_st0
, reg_mxcsr
;
234 reg_st0
= x86_64_register_number ("st0");
235 reg_mxcsr
= x86_64_register_number ("mxcsr");
237 gdb_assert (reg_st0
> 0 && reg_mxcsr
> reg_st0
);
239 for (i
= reg_st0
; i
<= reg_mxcsr
; i
++)
240 supply_register (i
, x86_64_fxsave_offset (fxsave
, i
));
243 /* Fill register REGNUM (if it is a floating-point or SSE register) in
244 *FXSAVE with the value in GDB's register array. If REGNUM is -1, do
245 this for all registers. This function doesn't touch any of the
246 reserved bits in *FXSAVE. */
249 fill_fpregset (elf_fpregset_t
* fxsave
, int regnum
)
251 int i
, last_regnum
= MXCSR_REGNUM
;
254 if (gdbarch_tdep (current_gdbarch
)->num_xmm_regs
== 0)
255 last_regnum
= FOP_REGNUM
;
257 for (i
= FP0_REGNUM
; i
<= last_regnum
; i
++)
258 if (regnum
== -1 || regnum
== i
)
260 ptr
= x86_64_fxsave_offset (fxsave
, i
);
262 regcache_collect (i
, ptr
);
266 /* Fetch all floating-point registers from process/thread TID and store
267 thier values in GDB's register array. */
270 fetch_fpregs (int tid
)
272 elf_fpregset_t fpregs
;
274 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
275 perror_with_name ("Couldn't get floating point status");
277 supply_fpregset (&fpregs
);
280 /* Store all valid floating-point registers in GDB's register array
281 into the process/thread specified by TID. */
284 store_fpregs (int tid
, int regno
)
286 elf_fpregset_t fpregs
;
288 if (ptrace (PTRACE_GETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
289 perror_with_name ("Couldn't get floating point status");
291 fill_fpregset (&fpregs
, regno
);
293 if (ptrace (PTRACE_SETFPREGS
, tid
, 0, (long) &fpregs
) < 0)
294 perror_with_name ("Couldn't write floating point status");
298 /* Transferring arbitrary registers between GDB and inferior. */
300 /* Fetch register REGNO from the child process. If REGNO is -1, do
301 this for all registers (including the floating point and SSE
305 fetch_inferior_registers (int regno
)
309 /* GNU/Linux LWP ID's are process ID's. */
310 if ((tid
= TIDGET (inferior_ptid
)) == 0)
311 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
320 if (GETREGS_SUPPLIES (regno
))
326 if (GETFPREGS_SUPPLIES (regno
))
332 internal_error (__FILE__
, __LINE__
,
333 "Got request for bad register number %d.", regno
);
336 /* Store register REGNO back into the child process. If REGNO is -1,
337 do this for all registers (including the floating point and SSE
340 store_inferior_registers (int regno
)
344 /* GNU/Linux LWP ID's are process ID's. */
345 if ((tid
= TIDGET (inferior_ptid
)) == 0)
346 tid
= PIDGET (inferior_ptid
); /* Not a threaded program. */
350 store_regs (tid
, regno
);
351 store_fpregs (tid
, regno
);
355 if (GETREGS_SUPPLIES (regno
))
357 store_regs (tid
, regno
);
361 if (GETFPREGS_SUPPLIES (regno
))
363 store_fpregs (tid
, regno
);
367 internal_error (__FILE__
, __LINE__
,
368 "Got request to store bad register number %d.", regno
);
372 static const unsigned char linux_syscall
[] = { 0x0f, 0x05 };
374 #define LINUX_SYSCALL_LEN (sizeof linux_syscall)
376 /* The system call number is stored in the %rax register. */
377 #define LINUX_SYSCALL_REGNUM 0 /* %rax */
379 /* We are specifically interested in the sigreturn and rt_sigreturn
382 #ifndef SYS_sigreturn
383 #define SYS_sigreturn __NR_sigreturn
385 #ifndef SYS_rt_sigreturn
386 #define SYS_rt_sigreturn __NR_rt_sigreturn
389 /* Offset to saved processor flags, from <asm/sigcontext.h>. */
390 #define LINUX_SIGCONTEXT_EFLAGS_OFFSET (152)
391 /* Offset to saved processor registers from <asm/ucontext.h> */
392 #define LINUX_UCONTEXT_SIGCONTEXT_OFFSET (36)
394 /* Interpreting register set info found in core files. */
395 /* Provide registers to GDB from a core file.
397 CORE_REG_SECT points to an array of bytes, which are the contents
398 of a `note' from a core file which BFD thinks might contain
399 register contents. CORE_REG_SIZE is its size.
401 WHICH says which register set corelow suspects this is:
402 0 --- the general-purpose register set, in elf_gregset_t format
403 2 --- the floating-point register set, in elf_fpregset_t format
405 REG_ADDR isn't used on GNU/Linux. */
408 fetch_core_registers (char *core_reg_sect
, unsigned core_reg_size
,
409 int which
, CORE_ADDR reg_addr
)
411 elf_gregset_t gregset
;
412 elf_fpregset_t fpregset
;
416 if (core_reg_size
!= sizeof (gregset
))
417 warning ("Wrong size gregset in core file.");
420 memcpy (&gregset
, core_reg_sect
, sizeof (gregset
));
421 supply_gregset (&gregset
);
426 if (core_reg_size
!= sizeof (fpregset
))
427 warning ("Wrong size fpregset in core file.");
430 memcpy (&fpregset
, core_reg_sect
, sizeof (fpregset
));
431 supply_fpregset (&fpregset
);
436 /* We've covered all the kinds of registers we know about here,
437 so this must be something we wouldn't know what to do with
438 anyway. Just ignore it. */
443 /* Register that we are able to handle GNU/Linux ELF core file formats. */
445 static struct core_fns linux_elf_core_fns
= {
446 bfd_target_elf_flavour
, /* core_flavour */
447 default_check_format
, /* check_format */
448 default_core_sniffer
, /* core_sniffer */
449 fetch_core_registers
, /* core_read_registers */
454 #if !defined (offsetof)
455 #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER)
458 /* Return the address of register REGNUM. BLOCKEND is the value of
459 u.u_ar0, which should point to the registers. */
461 x86_64_register_u_addr (CORE_ADDR blockend
, int regnum
)
467 if (IS_FP_REGNUM (regnum
))
469 fpstate
= ubase
+ ((char *) &u
.i387
.st_space
- (char *) &u
);
470 return (fpstate
+ 16 * (regnum
- FP0_REGNUM
));
472 else if (IS_SSE_REGNUM (regnum
))
474 fpstate
= ubase
+ ((char *) &u
.i387
.xmm_space
- (char *) &u
);
475 return (fpstate
+ 16 * (regnum
- XMM0_REGNUM
));
478 return (ubase
+ 8 * x86_64_regmap
[regnum
]);
482 _initialize_x86_64_linux_nat (void)
484 add_core_fns (&linux_elf_core_fns
);
490 return (sizeof (struct user
));