Commit | Line | Data |
---|---|---|
53e95fcf | 1 | /* Native-dependent code for Linux/x86-64. |
0a65a603 AC |
2 | |
3 | Copyright 2001, 2002 Free Software Foundation, Inc. | |
4 | ||
53e95fcf JS |
5 | Contributed by Jiri Smid, SuSE Labs. |
6 | ||
7 | This file is part of GDB. | |
8 | ||
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. | |
13 | ||
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. | |
18 | ||
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. */ | |
23 | ||
24 | #include "defs.h" | |
25 | #include "inferior.h" | |
26 | #include "gdbcore.h" | |
27 | #include "regcache.h" | |
28 | #include "i387-nat.h" | |
29 | #include "gdb_assert.h" | |
30 | #include "x86-64-tdep.h" | |
31 | ||
32 | #include <sys/ptrace.h> | |
33 | #include <sys/debugreg.h> | |
34 | #include <sys/syscall.h> | |
35 | #include <sys/procfs.h> | |
36 | ||
37 | static unsigned long | |
38 | x86_64_linux_dr_get (int regnum) | |
39 | { | |
40 | int tid; | |
41 | unsigned long value; | |
42 | ||
43 | /* FIXME: kettenis/2001-01-29: It's not clear what we should do with | |
44 | multi-threaded processes here. For now, pretend there is just | |
45 | one thread. */ | |
46 | tid = PIDGET (inferior_ptid); | |
47 | ||
48 | /* FIXME: kettenis/2001-03-27: Calling perror_with_name if the | |
49 | ptrace call fails breaks debugging remote targets. The correct | |
50 | way to fix this is to add the hardware breakpoint and watchpoint | |
51 | stuff to the target vectore. For now, just return zero if the | |
52 | ptrace call fails. */ | |
53 | errno = 0; | |
54 | value = ptrace (PT_READ_U, tid, | |
55 | offsetof (struct user, u_debugreg[regnum]), 0); | |
56 | if (errno != 0) | |
57 | #if 0 | |
58 | perror_with_name ("Couldn't read debug register"); | |
59 | #else | |
60 | return 0; | |
61 | #endif | |
62 | ||
63 | return value; | |
64 | } | |
65 | ||
66 | static void | |
67 | x86_64_linux_dr_set (int regnum, unsigned long value) | |
68 | { | |
69 | int tid; | |
70 | ||
71 | /* FIXME: kettenis/2001-01-29: It's not clear what we should do with | |
72 | multi-threaded processes here. For now, pretend there is just | |
73 | one thread. */ | |
74 | tid = PIDGET (inferior_ptid); | |
75 | ||
76 | errno = 0; | |
77 | ptrace (PT_WRITE_U, tid, | |
78 | offsetof (struct user, u_debugreg[regnum]), value); | |
79 | if (errno != 0) | |
80 | perror_with_name ("Couldn't write debug register"); | |
81 | } | |
82 | ||
83 | void | |
84 | x86_64_linux_dr_set_control (unsigned long control) | |
85 | { | |
86 | x86_64_linux_dr_set (DR_CONTROL, control); | |
87 | } | |
88 | ||
89 | void | |
90 | x86_64_linux_dr_set_addr (int regnum, CORE_ADDR addr) | |
91 | { | |
92 | gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); | |
93 | ||
94 | x86_64_linux_dr_set (DR_FIRSTADDR + regnum, addr); | |
95 | } | |
96 | ||
97 | void | |
98 | x86_64_linux_dr_reset_addr (int regnum) | |
99 | { | |
100 | gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR); | |
101 | ||
102 | x86_64_linux_dr_set (DR_FIRSTADDR + regnum, 0L); | |
103 | } | |
104 | ||
105 | unsigned long | |
106 | x86_64_linux_dr_get_status (void) | |
107 | { | |
108 | return x86_64_linux_dr_get (DR_STATUS); | |
109 | } | |
110 | \f | |
111 | ||
112 | /* The register sets used in Linux ELF core-dumps are identical to the | |
113 | register sets used by `ptrace'. */ | |
114 | ||
115 | #define GETREGS_SUPPLIES(regno) \ | |
116 | (0 <= (regno) && (regno) <= 17) | |
117 | #define GETFPREGS_SUPPLIES(regno) \ | |
118 | (FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM) | |
119 | ||
120 | #define PTRACE_XFER_TYPE unsigned long | |
121 | \f | |
122 | ||
123 | /* Transfering the general-purpose registers between GDB, inferiors | |
124 | and core files. */ | |
125 | ||
126 | /* Fill GDB's register array with the general-purpose register values | |
127 | in *GREGSETP. */ | |
128 | ||
129 | void | |
130 | supply_gregset (elf_gregset_t * gregsetp) | |
131 | { | |
132 | elf_greg_t *regp = (elf_greg_t *) gregsetp; | |
133 | int i; | |
134 | ||
135 | for (i = 0; i < X86_64_NUM_GREGS; i++) | |
136 | supply_register (i, (char *) (regp + x86_64_regmap[i])); | |
137 | } | |
138 | ||
139 | /* Fill register REGNO (if it is a general-purpose register) in | |
140 | *GREGSETPS with the value in GDB's register array. If REGNO is -1, | |
141 | do this for all registers. */ | |
142 | ||
143 | void | |
144 | fill_gregset (elf_gregset_t * gregsetp, int regno) | |
145 | { | |
146 | elf_greg_t *regp = (elf_greg_t *) gregsetp; | |
147 | int i; | |
148 | ||
149 | for (i = 0; i < X86_64_NUM_GREGS; i++) | |
150 | if ((regno == -1 || regno == i)) | |
94cd915f | 151 | read_register_gen (i, regp + x86_64_regmap[i]); |
53e95fcf JS |
152 | } |
153 | ||
154 | /* Fetch all general-purpose registers from process/thread TID and | |
155 | store their values in GDB's register array. */ | |
156 | ||
157 | static void | |
158 | fetch_regs (int tid) | |
159 | { | |
160 | elf_gregset_t regs; | |
161 | ||
162 | if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0) | |
163 | perror_with_name ("Couldn't get registers"); | |
164 | ||
165 | supply_gregset (®s); | |
166 | } | |
167 | ||
168 | /* Store all valid general-purpose registers in GDB's register array | |
169 | into the process/thread specified by TID. */ | |
170 | ||
171 | static void | |
172 | store_regs (int tid, int regno) | |
173 | { | |
174 | elf_gregset_t regs; | |
175 | ||
176 | if (ptrace (PTRACE_GETREGS, tid, 0, (long) ®s) < 0) | |
177 | perror_with_name ("Couldn't get registers"); | |
178 | ||
179 | fill_gregset (®s, regno); | |
180 | ||
181 | if (ptrace (PTRACE_SETREGS, tid, 0, (long) ®s) < 0) | |
182 | perror_with_name ("Couldn't write registers"); | |
183 | } | |
184 | \f | |
185 | ||
186 | /* Transfering floating-point registers between GDB, inferiors and cores. */ | |
187 | ||
188 | /* Fill GDB's register array with the floating-point register values in | |
189 | *FPREGSETP. */ | |
190 | ||
191 | void | |
192 | supply_fpregset (elf_fpregset_t * fpregsetp) | |
193 | { | |
194 | i387_supply_fxsave ((char *) fpregsetp); | |
195 | } | |
196 | ||
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. */ | |
200 | ||
201 | void | |
202 | fill_fpregset (elf_fpregset_t * fpregsetp, int regno) | |
203 | { | |
204 | i387_fill_fxsave ((char *) fpregsetp, regno); | |
205 | } | |
206 | ||
207 | /* Fetch all floating-point registers from process/thread TID and store | |
208 | thier values in GDB's register array. */ | |
209 | ||
210 | static void | |
211 | fetch_fpregs (int tid) | |
212 | { | |
213 | elf_fpregset_t fpregs; | |
214 | ||
215 | if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) | |
216 | perror_with_name ("Couldn't get floating point status"); | |
217 | ||
218 | supply_fpregset (&fpregs); | |
219 | } | |
220 | ||
221 | /* Store all valid floating-point registers in GDB's register array | |
222 | into the process/thread specified by TID. */ | |
223 | ||
224 | static void | |
225 | store_fpregs (int tid, int regno) | |
226 | { | |
227 | elf_fpregset_t fpregs; | |
228 | ||
229 | if (ptrace (PTRACE_GETFPREGS, tid, 0, (long) &fpregs) < 0) | |
230 | perror_with_name ("Couldn't get floating point status"); | |
231 | ||
232 | fill_fpregset (&fpregs, regno); | |
233 | ||
234 | if (ptrace (PTRACE_SETFPREGS, tid, 0, (long) &fpregs) < 0) | |
235 | perror_with_name ("Couldn't write floating point status"); | |
236 | } | |
237 | \f | |
238 | ||
239 | /* Transferring arbitrary registers between GDB and inferior. */ | |
240 | ||
241 | /* Fetch register REGNO from the child process. If REGNO is -1, do | |
242 | this for all registers (including the floating point and SSE | |
243 | registers). */ | |
244 | ||
245 | void | |
246 | fetch_inferior_registers (int regno) | |
247 | { | |
248 | int tid; | |
249 | ||
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. */ | |
253 | ||
254 | if (regno == -1) | |
255 | { | |
256 | fetch_regs (tid); | |
257 | fetch_fpregs (tid); | |
258 | return; | |
259 | } | |
260 | ||
261 | if (GETREGS_SUPPLIES (regno)) | |
262 | { | |
263 | fetch_regs (tid); | |
264 | return; | |
265 | } | |
266 | ||
267 | if (GETFPREGS_SUPPLIES (regno)) | |
268 | { | |
269 | fetch_fpregs (tid); | |
270 | return; | |
271 | } | |
272 | ||
273 | internal_error (__FILE__, __LINE__, | |
274 | "Got request for bad register number %d.", regno); | |
275 | } | |
276 | ||
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 | |
279 | registers). */ | |
280 | void | |
281 | store_inferior_registers (int regno) | |
282 | { | |
283 | int tid; | |
284 | ||
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. */ | |
288 | ||
289 | if (regno == -1) | |
290 | { | |
291 | store_regs (tid, regno); | |
292 | store_fpregs (tid, regno); | |
293 | return; | |
294 | } | |
295 | ||
296 | if (GETREGS_SUPPLIES (regno)) | |
297 | { | |
298 | store_regs (tid, regno); | |
299 | return; | |
300 | } | |
301 | ||
302 | if (GETFPREGS_SUPPLIES (regno)) | |
303 | { | |
304 | store_fpregs (tid, regno); | |
305 | return; | |
306 | } | |
307 | ||
308 | internal_error (__FILE__, __LINE__, | |
309 | "Got request to store bad register number %d.", regno); | |
310 | } | |
311 | \f | |
312 | ||
313 | static const unsigned char linux_syscall[] = { 0x0f, 0x05 }; | |
314 | ||
315 | #define LINUX_SYSCALL_LEN (sizeof linux_syscall) | |
316 | ||
317 | /* The system call number is stored in the %rax register. */ | |
318 | #define LINUX_SYSCALL_REGNUM 0 /* %rax */ | |
319 | ||
320 | /* We are specifically interested in the sigreturn and rt_sigreturn | |
321 | system calls. */ | |
322 | ||
323 | #ifndef SYS_sigreturn | |
324 | #define SYS_sigreturn __NR_sigreturn | |
325 | #endif | |
326 | #ifndef SYS_rt_sigreturn | |
327 | #define SYS_rt_sigreturn __NR_rt_sigreturn | |
328 | #endif | |
329 | ||
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) | |
334 | ||
335 | /* Resume execution of the inferior process. | |
336 | If STEP is nonzero, single-step it. | |
337 | If SIGNAL is nonzero, give it that signal. */ | |
338 | ||
339 | void | |
340 | child_resume (ptid_t ptid, int step, enum target_signal signal) | |
341 | { | |
342 | int pid = PIDGET (ptid); | |
343 | int request = PTRACE_CONT; | |
344 | ||
345 | if (pid == -1) | |
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); | |
350 | ||
351 | if (step) | |
352 | { | |
353 | CORE_ADDR pc = read_pc_pid (pid_to_ptid (pid)); | |
354 | unsigned char buf[LINUX_SYSCALL_LEN]; | |
355 | ||
356 | request = PTRACE_SINGLESTEP; | |
357 | ||
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. */ | |
365 | ||
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) | |
369 | { | |
370 | int syscall = | |
371 | read_register_pid (LINUX_SYSCALL_REGNUM, pid_to_ptid (pid)); | |
372 | ||
373 | /* Then check the system call number. */ | |
374 | if (syscall == SYS_rt_sigreturn) | |
375 | { | |
376 | CORE_ADDR sp = read_register (SP_REGNUM); | |
377 | CORE_ADDR addr = sp; | |
378 | unsigned long int eflags; | |
379 | ||
380 | addr += | |
381 | sizeof (struct siginfo) + LINUX_UCONTEXT_SIGCONTEXT_OFFSET; | |
382 | ||
383 | /* Set the trace flag in the context that's about to be | |
384 | restored. */ | |
385 | addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET; | |
386 | read_memory (addr, (char *) &eflags, 8); | |
387 | eflags |= 0x0100; | |
388 | write_memory (addr, (char *) &eflags, 8); | |
389 | } | |
390 | } | |
391 | } | |
392 | ||
393 | if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1) | |
394 | perror_with_name ("ptrace"); | |
395 | } | |
396 | \f | |
397 | ||
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. | |
401 | ||
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 | |
405 | anyway. */ | |
406 | ||
407 | int | |
408 | child_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, | |
0a65a603 | 409 | struct mem_attrib *attrib, struct target_ops *target) |
53e95fcf JS |
410 | { |
411 | register int i; | |
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. */ | |
415 | register int count | |
416 | = (((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1) | |
417 | / sizeof (PTRACE_XFER_TYPE); | |
418 | /* Allocate buffer of that many longwords. */ | |
94cd915f MS |
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. */ | |
53e95fcf JS |
422 | register PTRACE_XFER_TYPE *buffer |
423 | = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE)); | |
424 | ||
425 | if (write) | |
426 | { | |
427 | /* Fill start and end extra bytes of buffer with existing memory data. */ | |
428 | if (addr != memaddr || len < (int) sizeof (PTRACE_XFER_TYPE)) | |
429 | { | |
430 | /* Need part of initial word -- fetch it. */ | |
431 | ptrace (PT_READ_I, PIDGET (inferior_ptid), | |
432 | (PTRACE_ARG3_TYPE) addr, buffer); | |
433 | } | |
434 | ||
435 | if (count > 1) /* FIXME, avoid if even boundary */ | |
436 | { | |
437 | ptrace (PT_READ_I, PIDGET (inferior_ptid), | |
438 | ((PTRACE_ARG3_TYPE) | |
439 | (addr + (count - 1) * sizeof (PTRACE_XFER_TYPE))), | |
440 | buffer + count - 1); | |
441 | } | |
442 | ||
443 | /* Copy data to be written over corresponding part of buffer */ | |
444 | ||
445 | memcpy ((char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), | |
446 | myaddr, len); | |
447 | ||
448 | /* Write the entire buffer. */ | |
449 | ||
450 | for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) | |
451 | { | |
452 | errno = 0; | |
453 | ptrace (PT_WRITE_D, PIDGET (inferior_ptid), | |
454 | (PTRACE_ARG3_TYPE) addr, buffer[i]); | |
455 | if (errno) | |
456 | { | |
457 | /* Using the appropriate one (I or D) is necessary for | |
458 | Gould NP1, at least. */ | |
459 | errno = 0; | |
460 | ptrace (PT_WRITE_I, PIDGET (inferior_ptid), | |
461 | (PTRACE_ARG3_TYPE) addr, buffer[i]); | |
462 | } | |
463 | if (errno) | |
464 | return 0; | |
465 | } | |
466 | #ifdef CLEAR_INSN_CACHE | |
467 | CLEAR_INSN_CACHE (); | |
468 | #endif | |
469 | } | |
470 | else | |
471 | { | |
472 | /* Read all the longwords */ | |
473 | for (i = 0; i < count; i++, addr += sizeof (PTRACE_XFER_TYPE)) | |
474 | { | |
475 | errno = 0; | |
476 | ptrace (PT_READ_I, PIDGET (inferior_ptid), | |
477 | (PTRACE_ARG3_TYPE) addr, buffer + i); | |
478 | if (errno) | |
479 | return 0; | |
480 | } | |
481 | ||
482 | /* Copy appropriate bytes out of the buffer. */ | |
483 | memcpy (myaddr, | |
484 | (char *) buffer + (memaddr & (sizeof (PTRACE_XFER_TYPE) - 1)), | |
485 | len); | |
486 | } | |
487 | return len; | |
488 | } | |
489 | ||
490 | /* Interpreting register set info found in core files. */ | |
491 | ||
492 | /* Provide registers to GDB from a core file. | |
493 | ||
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. | |
497 | ||
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 | |
501 | ||
502 | REG_ADDR isn't used on Linux. */ | |
503 | ||
504 | static void | |
505 | fetch_core_registers (char *core_reg_sect, unsigned core_reg_size, | |
506 | int which, CORE_ADDR reg_addr) | |
507 | { | |
508 | elf_gregset_t gregset; | |
509 | elf_fpregset_t fpregset; | |
510 | switch (which) | |
511 | { | |
512 | case 0: | |
513 | if (core_reg_size != sizeof (gregset)) | |
514 | warning ("Wrong size gregset in core file."); | |
515 | else | |
516 | { | |
517 | memcpy (&gregset, core_reg_sect, sizeof (gregset)); | |
518 | supply_gregset (&gregset); | |
519 | } | |
520 | break; | |
521 | ||
522 | case 2: | |
523 | if (core_reg_size != sizeof (fpregset)) | |
524 | warning ("Wrong size fpregset in core file."); | |
525 | else | |
526 | { | |
527 | memcpy (&fpregset, core_reg_sect, sizeof (fpregset)); | |
528 | supply_fpregset (&fpregset); | |
529 | } | |
530 | break; | |
531 | ||
532 | default: | |
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. */ | |
536 | break; | |
537 | } | |
538 | } | |
539 | ||
540 | /* Register that we are able to handle Linux ELF core file formats. */ | |
541 | ||
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 */ | |
547 | NULL /* next */ | |
548 | }; | |
549 | \f | |
550 | ||
551 | #if !defined (offsetof) | |
552 | #define offsetof(TYPE, MEMBER) ((unsigned long) &((TYPE *)0)->MEMBER) | |
553 | #endif | |
554 | ||
555 | /* Record the value of the debug control register. */ | |
556 | static long debug_control_mirror; | |
557 | ||
558 | /* Record which address associates with which register. */ | |
559 | static CORE_ADDR address_lookup[DR_LASTADDR - DR_FIRSTADDR + 1]; | |
560 | ||
b7c4cbf8 AJ |
561 | /* Return the address of register REGNUM. BLOCKEND is the value of |
562 | u.u_ar0, which should point to the registers. */ | |
563 | CORE_ADDR | |
564 | x86_64_register_u_addr (CORE_ADDR blockend, int regnum) | |
565 | { | |
566 | struct user u; | |
567 | CORE_ADDR fpstate; | |
568 | CORE_ADDR ubase; | |
569 | ubase = blockend; | |
570 | if (IS_FP_REGNUM(regnum)) | |
571 | { | |
572 | fpstate = ubase + ((char *) &u.i387.st_space - (char *) &u); | |
573 | return (fpstate + 16 * (regnum - FP0_REGNUM)); | |
574 | } | |
575 | else if (IS_SSE_REGNUM(regnum)) | |
576 | { | |
577 | fpstate = ubase + ((char *) &u.i387.xmm_space - (char *) &u); | |
578 | return (fpstate + 16 * (regnum - XMM0_REGNUM)); | |
579 | } | |
580 | else | |
581 | return (ubase + 8 * x86_64_regmap[regnum]); | |
582 | } | |
583 | ||
53e95fcf JS |
584 | void |
585 | _initialize_x86_64_linux_nat (void) | |
586 | { | |
587 | add_core_fns (&linux_elf_core_fns); | |
588 | } |