1 /* GNU/Linux on ARM native support.
2 Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
25 #include "gdb_string.h"
28 #include "linux-nat.h"
29 #include "target-descriptions.h"
30 #include "xml-support.h"
33 #include "arm-linux-tdep.h"
36 #include <sys/ptrace.h>
37 #include <sys/utsname.h>
38 #include <sys/procfs.h>
40 /* Prototypes for supply_gregset etc. */
43 /* Defines ps_err_e, struct ps_prochandle. */
44 #include "gdb_proc_service.h"
46 #ifndef PTRACE_GET_THREAD_AREA
47 #define PTRACE_GET_THREAD_AREA 22
50 #ifndef PTRACE_GETWMMXREGS
51 #define PTRACE_GETWMMXREGS 18
52 #define PTRACE_SETWMMXREGS 19
55 /* A flag for whether the WMMX registers are available. */
56 static int arm_linux_has_wmmx_registers
;
58 extern int arm_apcs_32
;
60 /* The following variables are used to determine the version of the
61 underlying GNU/Linux operating system. Examples:
63 GNU/Linux 2.0.35 GNU/Linux 2.2.12
64 os_version = 0x00020023 os_version = 0x0002020c
65 os_major = 2 os_major = 2
66 os_minor = 0 os_minor = 2
67 os_release = 35 os_release = 12
69 Note: os_version = (os_major << 16) | (os_minor << 8) | os_release
71 These are initialized using get_linux_version() from
72 _initialize_arm_linux_nat(). */
74 static unsigned int os_version
, os_major
, os_minor
, os_release
;
76 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
77 case we may be tracing more than one process at a time. In that
78 case, inferior_ptid will contain the main process ID and the
79 individual thread (process) ID. get_thread_id () is used to get
80 the thread id if it's available, and the process id otherwise. */
83 get_thread_id (ptid_t ptid
)
85 int tid
= TIDGET (ptid
);
90 #define GET_THREAD_ID(PTID) get_thread_id (PTID)
92 /* Get the value of a particular register from the floating point
93 state of the process and store it into regcache. */
96 fetch_fpregister (struct regcache
*regcache
, int regno
)
99 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
101 /* Get the thread id for the ptrace call. */
102 tid
= GET_THREAD_ID (inferior_ptid
);
104 /* Read the floating point state. */
105 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
108 warning (_("Unable to fetch floating point register."));
113 if (ARM_FPS_REGNUM
== regno
)
114 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
115 fp
+ NWFPE_FPSR_OFFSET
);
117 /* Fetch the floating point register. */
118 if (regno
>= ARM_F0_REGNUM
&& regno
<= ARM_F7_REGNUM
)
119 supply_nwfpe_register (regcache
, regno
, fp
);
122 /* Get the whole floating point state of the process and store it
126 fetch_fpregs (struct regcache
*regcache
)
129 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
131 /* Get the thread id for the ptrace call. */
132 tid
= GET_THREAD_ID (inferior_ptid
);
134 /* Read the floating point state. */
135 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
138 warning (_("Unable to fetch the floating point registers."));
143 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
144 fp
+ NWFPE_FPSR_OFFSET
);
146 /* Fetch the floating point registers. */
147 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
148 supply_nwfpe_register (regcache
, regno
, fp
);
151 /* Save a particular register into the floating point state of the
152 process using the contents from regcache. */
155 store_fpregister (const struct regcache
*regcache
, int regno
)
158 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
160 /* Get the thread id for the ptrace call. */
161 tid
= GET_THREAD_ID (inferior_ptid
);
163 /* Read the floating point state. */
164 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
167 warning (_("Unable to fetch the floating point registers."));
172 if (ARM_FPS_REGNUM
== regno
&& regcache_valid_p (regcache
, ARM_FPS_REGNUM
))
173 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
, fp
+ NWFPE_FPSR_OFFSET
);
175 /* Store the floating point register. */
176 if (regno
>= ARM_F0_REGNUM
&& regno
<= ARM_F7_REGNUM
)
177 collect_nwfpe_register (regcache
, regno
, fp
);
179 ret
= ptrace (PTRACE_SETFPREGS
, tid
, 0, fp
);
182 warning (_("Unable to store floating point register."));
187 /* Save the whole floating point state of the process using
188 the contents from regcache. */
191 store_fpregs (const struct regcache
*regcache
)
194 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
196 /* Get the thread id for the ptrace call. */
197 tid
= GET_THREAD_ID (inferior_ptid
);
199 /* Read the floating point state. */
200 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
203 warning (_("Unable to fetch the floating point registers."));
208 if (regcache_valid_p (regcache
, ARM_FPS_REGNUM
))
209 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
, fp
+ NWFPE_FPSR_OFFSET
);
211 /* Store the floating point registers. */
212 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
213 if (regcache_valid_p (regcache
, regno
))
214 collect_nwfpe_register (regcache
, regno
, fp
);
216 ret
= ptrace (PTRACE_SETFPREGS
, tid
, 0, fp
);
219 warning (_("Unable to store floating point registers."));
224 /* Fetch a general register of the process and store into
228 fetch_register (struct regcache
*regcache
, int regno
)
233 /* Get the thread id for the ptrace call. */
234 tid
= GET_THREAD_ID (inferior_ptid
);
236 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
239 warning (_("Unable to fetch general register."));
243 if (regno
>= ARM_A1_REGNUM
&& regno
< ARM_PC_REGNUM
)
244 regcache_raw_supply (regcache
, regno
, (char *) ®s
[regno
]);
246 if (ARM_PS_REGNUM
== regno
)
249 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
250 (char *) ®s
[ARM_CPSR_REGNUM
]);
252 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
253 (char *) ®s
[ARM_PC_REGNUM
]);
256 if (ARM_PC_REGNUM
== regno
)
258 regs
[ARM_PC_REGNUM
] = gdbarch_addr_bits_remove
259 (current_gdbarch
, regs
[ARM_PC_REGNUM
]);
260 regcache_raw_supply (regcache
, ARM_PC_REGNUM
,
261 (char *) ®s
[ARM_PC_REGNUM
]);
265 /* Fetch all general registers of the process and store into
269 fetch_regs (struct regcache
*regcache
)
274 /* Get the thread id for the ptrace call. */
275 tid
= GET_THREAD_ID (inferior_ptid
);
277 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
280 warning (_("Unable to fetch general registers."));
284 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
285 regcache_raw_supply (regcache
, regno
, (char *) ®s
[regno
]);
288 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
289 (char *) ®s
[ARM_CPSR_REGNUM
]);
291 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
292 (char *) ®s
[ARM_PC_REGNUM
]);
294 regs
[ARM_PC_REGNUM
] = gdbarch_addr_bits_remove
295 (current_gdbarch
, regs
[ARM_PC_REGNUM
]);
296 regcache_raw_supply (regcache
, ARM_PC_REGNUM
,
297 (char *) ®s
[ARM_PC_REGNUM
]);
300 /* Store all general registers of the process from the values in
304 store_register (const struct regcache
*regcache
, int regno
)
309 if (!regcache_valid_p (regcache
, regno
))
312 /* Get the thread id for the ptrace call. */
313 tid
= GET_THREAD_ID (inferior_ptid
);
315 /* Get the general registers from the process. */
316 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
319 warning (_("Unable to fetch general registers."));
323 if (regno
>= ARM_A1_REGNUM
&& regno
<= ARM_PC_REGNUM
)
324 regcache_raw_collect (regcache
, regno
, (char *) ®s
[regno
]);
325 else if (arm_apcs_32
&& regno
== ARM_PS_REGNUM
)
326 regcache_raw_collect (regcache
, regno
,
327 (char *) ®s
[ARM_CPSR_REGNUM
]);
328 else if (!arm_apcs_32
&& regno
== ARM_PS_REGNUM
)
329 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
330 (char *) ®s
[ARM_PC_REGNUM
]);
332 ret
= ptrace (PTRACE_SETREGS
, tid
, 0, ®s
);
335 warning (_("Unable to store general register."));
341 store_regs (const struct regcache
*regcache
)
346 /* Get the thread id for the ptrace call. */
347 tid
= GET_THREAD_ID (inferior_ptid
);
349 /* Fetch the general registers. */
350 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
353 warning (_("Unable to fetch general registers."));
357 for (regno
= ARM_A1_REGNUM
; regno
<= ARM_PC_REGNUM
; regno
++)
359 if (regcache_valid_p (regcache
, regno
))
360 regcache_raw_collect (regcache
, regno
, (char *) ®s
[regno
]);
363 if (arm_apcs_32
&& regcache_valid_p (regcache
, ARM_PS_REGNUM
))
364 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
365 (char *) ®s
[ARM_CPSR_REGNUM
]);
367 ret
= ptrace (PTRACE_SETREGS
, tid
, 0, ®s
);
371 warning (_("Unable to store general registers."));
376 /* Fetch all WMMX registers of the process and store into
379 #define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
382 fetch_wmmx_regs (struct regcache
*regcache
)
384 char regbuf
[IWMMXT_REGS_SIZE
];
387 /* Get the thread id for the ptrace call. */
388 tid
= GET_THREAD_ID (inferior_ptid
);
390 ret
= ptrace (PTRACE_GETWMMXREGS
, tid
, 0, regbuf
);
393 warning (_("Unable to fetch WMMX registers."));
397 for (regno
= 0; regno
< 16; regno
++)
398 regcache_raw_supply (regcache
, regno
+ ARM_WR0_REGNUM
,
401 for (regno
= 0; regno
< 2; regno
++)
402 regcache_raw_supply (regcache
, regno
+ ARM_WCSSF_REGNUM
,
403 ®buf
[16 * 8 + regno
* 4]);
405 for (regno
= 0; regno
< 4; regno
++)
406 regcache_raw_supply (regcache
, regno
+ ARM_WCGR0_REGNUM
,
407 ®buf
[16 * 8 + 2 * 4 + regno
* 4]);
411 store_wmmx_regs (const struct regcache
*regcache
)
413 char regbuf
[IWMMXT_REGS_SIZE
];
416 /* Get the thread id for the ptrace call. */
417 tid
= GET_THREAD_ID (inferior_ptid
);
419 ret
= ptrace (PTRACE_GETWMMXREGS
, tid
, 0, regbuf
);
422 warning (_("Unable to fetch WMMX registers."));
426 for (regno
= 0; regno
< 16; regno
++)
427 if (regcache_valid_p (regcache
, regno
+ ARM_WR0_REGNUM
))
428 regcache_raw_collect (regcache
, regno
+ ARM_WR0_REGNUM
,
431 for (regno
= 0; regno
< 2; regno
++)
432 if (regcache_valid_p (regcache
, regno
+ ARM_WCSSF_REGNUM
))
433 regcache_raw_collect (regcache
, regno
+ ARM_WCSSF_REGNUM
,
434 ®buf
[16 * 8 + regno
* 4]);
436 for (regno
= 0; regno
< 4; regno
++)
437 if (regcache_valid_p (regcache
, regno
+ ARM_WCGR0_REGNUM
))
438 regcache_raw_collect (regcache
, regno
+ ARM_WCGR0_REGNUM
,
439 ®buf
[16 * 8 + 2 * 4 + regno
* 4]);
441 ret
= ptrace (PTRACE_SETWMMXREGS
, tid
, 0, regbuf
);
445 warning (_("Unable to store WMMX registers."));
450 /* Fetch registers from the child process. Fetch all registers if
451 regno == -1, otherwise fetch all general registers or all floating
452 point registers depending upon the value of regno. */
455 arm_linux_fetch_inferior_registers (struct regcache
*regcache
, int regno
)
459 fetch_regs (regcache
);
460 fetch_fpregs (regcache
);
461 if (arm_linux_has_wmmx_registers
)
462 fetch_wmmx_regs (regcache
);
466 if (regno
< ARM_F0_REGNUM
|| regno
== ARM_PS_REGNUM
)
467 fetch_register (regcache
, regno
);
468 else if (regno
>= ARM_F0_REGNUM
&& regno
<= ARM_FPS_REGNUM
)
469 fetch_fpregister (regcache
, regno
);
470 else if (arm_linux_has_wmmx_registers
471 && regno
>= ARM_WR0_REGNUM
&& regno
<= ARM_WCGR7_REGNUM
)
472 fetch_wmmx_regs (regcache
);
476 /* Store registers back into the inferior. Store all registers if
477 regno == -1, otherwise store all general registers or all floating
478 point registers depending upon the value of regno. */
481 arm_linux_store_inferior_registers (struct regcache
*regcache
, int regno
)
485 store_regs (regcache
);
486 store_fpregs (regcache
);
487 if (arm_linux_has_wmmx_registers
)
488 store_wmmx_regs (regcache
);
492 if (regno
< ARM_F0_REGNUM
|| regno
== ARM_PS_REGNUM
)
493 store_register (regcache
, regno
);
494 else if ((regno
>= ARM_F0_REGNUM
) && (regno
<= ARM_FPS_REGNUM
))
495 store_fpregister (regcache
, regno
);
496 else if (arm_linux_has_wmmx_registers
497 && regno
>= ARM_WR0_REGNUM
&& regno
<= ARM_WCGR7_REGNUM
)
498 store_wmmx_regs (regcache
);
502 /* Wrapper functions for the standard regset handling, used by
506 fill_gregset (const struct regcache
*regcache
,
507 gdb_gregset_t
*gregsetp
, int regno
)
509 arm_linux_collect_gregset (NULL
, regcache
, regno
, gregsetp
, 0);
513 supply_gregset (struct regcache
*regcache
, const gdb_gregset_t
*gregsetp
)
515 arm_linux_supply_gregset (NULL
, regcache
, -1, gregsetp
, 0);
519 fill_fpregset (const struct regcache
*regcache
,
520 gdb_fpregset_t
*fpregsetp
, int regno
)
522 arm_linux_collect_nwfpe (NULL
, regcache
, regno
, fpregsetp
, 0);
525 /* Fill GDB's register array with the floating-point register values
529 supply_fpregset (struct regcache
*regcache
, const gdb_fpregset_t
*fpregsetp
)
531 arm_linux_supply_nwfpe (NULL
, regcache
, -1, fpregsetp
, 0);
534 /* Fetch the thread-local storage pointer for libthread_db. */
537 ps_get_thread_area (const struct ps_prochandle
*ph
,
538 lwpid_t lwpid
, int idx
, void **base
)
540 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
543 /* IDX is the bias from the thread pointer to the beginning of the
544 thread descriptor. It has to be subtracted due to implementation
545 quirks in libthread_db. */
546 *base
= (void *) ((char *)*base
- idx
);
552 get_linux_version (unsigned int *vmajor
,
553 unsigned int *vminor
,
554 unsigned int *vrelease
)
557 char *pmajor
, *pminor
, *prelease
, *tail
;
559 if (-1 == uname (&info
))
561 warning (_("Unable to determine GNU/Linux version."));
565 pmajor
= strtok (info
.release
, ".");
566 pminor
= strtok (NULL
, ".");
567 prelease
= strtok (NULL
, ".");
569 *vmajor
= (unsigned int) strtoul (pmajor
, &tail
, 0);
570 *vminor
= (unsigned int) strtoul (pminor
, &tail
, 0);
571 *vrelease
= (unsigned int) strtoul (prelease
, &tail
, 0);
573 return ((*vmajor
<< 16) | (*vminor
<< 8) | *vrelease
);
576 static LONGEST (*super_xfer_partial
) (struct target_ops
*, enum target_object
,
577 const char *, gdb_byte
*, const gdb_byte
*,
581 arm_linux_xfer_partial (struct target_ops
*ops
,
582 enum target_object object
,
584 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
585 ULONGEST offset
, LONGEST len
)
587 if (object
== TARGET_OBJECT_AVAILABLE_FEATURES
)
589 if (annex
!= NULL
&& strcmp (annex
, "target.xml") == 0)
592 char regbuf
[IWMMXT_REGS_SIZE
];
594 ret
= ptrace (PTRACE_GETWMMXREGS
, GET_THREAD_ID (inferior_ptid
),
597 arm_linux_has_wmmx_registers
= 0;
599 arm_linux_has_wmmx_registers
= 1;
601 if (arm_linux_has_wmmx_registers
)
602 annex
= "arm-with-iwmmxt.xml";
607 return xml_builtin_xfer_partial (annex
, readbuf
, writebuf
, offset
, len
);
610 return super_xfer_partial (ops
, object
, annex
, readbuf
, writebuf
,
614 void _initialize_arm_linux_nat (void);
617 _initialize_arm_linux_nat (void)
619 struct target_ops
*t
;
621 os_version
= get_linux_version (&os_major
, &os_minor
, &os_release
);
623 /* Fill in the generic GNU/Linux methods. */
626 /* Add our register access methods. */
627 t
->to_fetch_registers
= arm_linux_fetch_inferior_registers
;
628 t
->to_store_registers
= arm_linux_store_inferior_registers
;
630 /* Override the default to_xfer_partial. */
631 super_xfer_partial
= t
->to_xfer_partial
;
632 t
->to_xfer_partial
= arm_linux_xfer_partial
;
634 /* Register the target. */
635 linux_nat_add_target (t
);