1 /* GNU/Linux on ARM native support.
2 Copyright (C) 1999-2015 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "linux-nat.h"
25 #include "target-descriptions.h"
28 #include "gdbthread.h"
31 #include "arm-linux-tdep.h"
33 #include <elf/common.h>
35 #include <sys/ptrace.h>
36 #include <sys/utsname.h>
37 #include <sys/procfs.h>
39 /* Prototypes for supply_gregset etc. */
42 /* Defines ps_err_e, struct ps_prochandle. */
43 #include "gdb_proc_service.h"
45 #ifndef PTRACE_GET_THREAD_AREA
46 #define PTRACE_GET_THREAD_AREA 22
49 #ifndef PTRACE_GETWMMXREGS
50 #define PTRACE_GETWMMXREGS 18
51 #define PTRACE_SETWMMXREGS 19
54 #ifndef PTRACE_GETVFPREGS
55 #define PTRACE_GETVFPREGS 27
56 #define PTRACE_SETVFPREGS 28
59 #ifndef PTRACE_GETHBPREGS
60 #define PTRACE_GETHBPREGS 29
61 #define PTRACE_SETHBPREGS 30
64 extern int arm_apcs_32
;
66 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
67 case we may be tracing more than one process at a time. In that
68 case, inferior_ptid will contain the main process ID and the
69 individual thread (process) ID. get_thread_id () is used to get
70 the thread id if it's available, and the process id otherwise. */
73 get_thread_id (ptid_t ptid
)
75 int tid
= ptid_get_lwp (ptid
);
77 tid
= ptid_get_pid (ptid
);
81 #define GET_THREAD_ID(PTID) get_thread_id (PTID)
83 /* Get the value of a particular register from the floating point
84 state of the process and store it into regcache. */
87 fetch_fpregister (struct regcache
*regcache
, int regno
)
90 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
92 /* Get the thread id for the ptrace call. */
93 tid
= GET_THREAD_ID (inferior_ptid
);
95 /* Read the floating point state. */
96 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
99 warning (_("Unable to fetch floating point register."));
104 if (ARM_FPS_REGNUM
== regno
)
105 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
106 fp
+ NWFPE_FPSR_OFFSET
);
108 /* Fetch the floating point register. */
109 if (regno
>= ARM_F0_REGNUM
&& regno
<= ARM_F7_REGNUM
)
110 supply_nwfpe_register (regcache
, regno
, fp
);
113 /* Get the whole floating point state of the process and store it
117 fetch_fpregs (struct regcache
*regcache
)
120 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
122 /* Get the thread id for the ptrace call. */
123 tid
= GET_THREAD_ID (inferior_ptid
);
125 /* Read the floating point state. */
126 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
129 warning (_("Unable to fetch the floating point registers."));
134 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
135 fp
+ NWFPE_FPSR_OFFSET
);
137 /* Fetch the floating point registers. */
138 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
139 supply_nwfpe_register (regcache
, regno
, fp
);
142 /* Save a particular register into the floating point state of the
143 process using the contents from regcache. */
146 store_fpregister (const struct regcache
*regcache
, int regno
)
149 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
151 /* Get the thread id for the ptrace call. */
152 tid
= GET_THREAD_ID (inferior_ptid
);
154 /* Read the floating point state. */
155 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
158 warning (_("Unable to fetch the floating point registers."));
163 if (ARM_FPS_REGNUM
== regno
164 && REG_VALID
== regcache_register_status (regcache
, ARM_FPS_REGNUM
))
165 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
, fp
+ NWFPE_FPSR_OFFSET
);
167 /* Store the floating point register. */
168 if (regno
>= ARM_F0_REGNUM
&& regno
<= ARM_F7_REGNUM
)
169 collect_nwfpe_register (regcache
, regno
, fp
);
171 ret
= ptrace (PTRACE_SETFPREGS
, tid
, 0, fp
);
174 warning (_("Unable to store floating point register."));
179 /* Save the whole floating point state of the process using
180 the contents from regcache. */
183 store_fpregs (const struct regcache
*regcache
)
186 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
188 /* Get the thread id for the ptrace call. */
189 tid
= GET_THREAD_ID (inferior_ptid
);
191 /* Read the floating point state. */
192 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
195 warning (_("Unable to fetch the floating point registers."));
200 if (REG_VALID
== regcache_register_status (regcache
, ARM_FPS_REGNUM
))
201 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
, fp
+ NWFPE_FPSR_OFFSET
);
203 /* Store the floating point registers. */
204 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
205 if (REG_VALID
== regcache_register_status (regcache
, regno
))
206 collect_nwfpe_register (regcache
, regno
, fp
);
208 ret
= ptrace (PTRACE_SETFPREGS
, tid
, 0, fp
);
211 warning (_("Unable to store floating point registers."));
216 /* Fetch a general register of the process and store into
220 fetch_register (struct regcache
*regcache
, int regno
)
225 /* Get the thread id for the ptrace call. */
226 tid
= GET_THREAD_ID (inferior_ptid
);
228 if (have_ptrace_getregset
)
232 iov
.iov_base
= ®s
;
233 iov
.iov_len
= sizeof (regs
);
235 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
);
238 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
242 warning (_("Unable to fetch general register."));
246 if (regno
>= ARM_A1_REGNUM
&& regno
< ARM_PC_REGNUM
)
247 regcache_raw_supply (regcache
, regno
, (char *) ®s
[regno
]);
249 if (ARM_PS_REGNUM
== regno
)
252 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
253 (char *) ®s
[ARM_CPSR_GREGNUM
]);
255 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
256 (char *) ®s
[ARM_PC_REGNUM
]);
259 if (ARM_PC_REGNUM
== regno
)
261 regs
[ARM_PC_REGNUM
] = gdbarch_addr_bits_remove
262 (get_regcache_arch (regcache
),
263 regs
[ARM_PC_REGNUM
]);
264 regcache_raw_supply (regcache
, ARM_PC_REGNUM
,
265 (char *) ®s
[ARM_PC_REGNUM
]);
269 /* Fetch all general registers of the process and store into
273 fetch_regs (struct regcache
*regcache
)
278 /* Get the thread id for the ptrace call. */
279 tid
= GET_THREAD_ID (inferior_ptid
);
281 if (have_ptrace_getregset
)
285 iov
.iov_base
= ®s
;
286 iov
.iov_len
= sizeof (regs
);
288 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
);
291 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
295 warning (_("Unable to fetch general registers."));
299 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
300 regcache_raw_supply (regcache
, regno
, (char *) ®s
[regno
]);
303 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
304 (char *) ®s
[ARM_CPSR_GREGNUM
]);
306 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
307 (char *) ®s
[ARM_PC_REGNUM
]);
309 regs
[ARM_PC_REGNUM
] = gdbarch_addr_bits_remove
310 (get_regcache_arch (regcache
), regs
[ARM_PC_REGNUM
]);
311 regcache_raw_supply (regcache
, ARM_PC_REGNUM
,
312 (char *) ®s
[ARM_PC_REGNUM
]);
315 /* Store all general registers of the process from the values in
319 store_register (const struct regcache
*regcache
, int regno
)
324 if (REG_VALID
!= regcache_register_status (regcache
, regno
))
327 /* Get the thread id for the ptrace call. */
328 tid
= GET_THREAD_ID (inferior_ptid
);
330 /* Get the general registers from the process. */
331 if (have_ptrace_getregset
)
335 iov
.iov_base
= ®s
;
336 iov
.iov_len
= sizeof (regs
);
338 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
);
341 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
345 warning (_("Unable to fetch general registers."));
349 if (regno
>= ARM_A1_REGNUM
&& regno
<= ARM_PC_REGNUM
)
350 regcache_raw_collect (regcache
, regno
, (char *) ®s
[regno
]);
351 else if (arm_apcs_32
&& regno
== ARM_PS_REGNUM
)
352 regcache_raw_collect (regcache
, regno
,
353 (char *) ®s
[ARM_CPSR_GREGNUM
]);
354 else if (!arm_apcs_32
&& regno
== ARM_PS_REGNUM
)
355 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
356 (char *) ®s
[ARM_PC_REGNUM
]);
358 if (have_ptrace_getregset
)
362 iov
.iov_base
= ®s
;
363 iov
.iov_len
= sizeof (regs
);
365 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_PRSTATUS
, &iov
);
368 ret
= ptrace (PTRACE_SETREGS
, tid
, 0, ®s
);
372 warning (_("Unable to store general register."));
378 store_regs (const struct regcache
*regcache
)
383 /* Get the thread id for the ptrace call. */
384 tid
= GET_THREAD_ID (inferior_ptid
);
386 /* Fetch the general registers. */
387 if (have_ptrace_getregset
)
391 iov
.iov_base
= ®s
;
392 iov
.iov_len
= sizeof (regs
);
394 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
);
397 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
401 warning (_("Unable to fetch general registers."));
405 for (regno
= ARM_A1_REGNUM
; regno
<= ARM_PC_REGNUM
; regno
++)
407 if (REG_VALID
== regcache_register_status (regcache
, regno
))
408 regcache_raw_collect (regcache
, regno
, (char *) ®s
[regno
]);
411 if (arm_apcs_32
&& REG_VALID
== regcache_register_status (regcache
, ARM_PS_REGNUM
))
412 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
413 (char *) ®s
[ARM_CPSR_GREGNUM
]);
415 if (have_ptrace_getregset
)
419 iov
.iov_base
= ®s
;
420 iov
.iov_len
= sizeof (regs
);
422 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_PRSTATUS
, &iov
);
425 ret
= ptrace (PTRACE_SETREGS
, tid
, 0, ®s
);
429 warning (_("Unable to store general registers."));
434 /* Fetch all WMMX registers of the process and store into
437 #define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
440 fetch_wmmx_regs (struct regcache
*regcache
)
442 char regbuf
[IWMMXT_REGS_SIZE
];
445 /* Get the thread id for the ptrace call. */
446 tid
= GET_THREAD_ID (inferior_ptid
);
448 ret
= ptrace (PTRACE_GETWMMXREGS
, tid
, 0, regbuf
);
451 warning (_("Unable to fetch WMMX registers."));
455 for (regno
= 0; regno
< 16; regno
++)
456 regcache_raw_supply (regcache
, regno
+ ARM_WR0_REGNUM
,
459 for (regno
= 0; regno
< 2; regno
++)
460 regcache_raw_supply (regcache
, regno
+ ARM_WCSSF_REGNUM
,
461 ®buf
[16 * 8 + regno
* 4]);
463 for (regno
= 0; regno
< 4; regno
++)
464 regcache_raw_supply (regcache
, regno
+ ARM_WCGR0_REGNUM
,
465 ®buf
[16 * 8 + 2 * 4 + regno
* 4]);
469 store_wmmx_regs (const struct regcache
*regcache
)
471 char regbuf
[IWMMXT_REGS_SIZE
];
474 /* Get the thread id for the ptrace call. */
475 tid
= GET_THREAD_ID (inferior_ptid
);
477 ret
= ptrace (PTRACE_GETWMMXREGS
, tid
, 0, regbuf
);
480 warning (_("Unable to fetch WMMX registers."));
484 for (regno
= 0; regno
< 16; regno
++)
485 if (REG_VALID
== regcache_register_status (regcache
,
486 regno
+ ARM_WR0_REGNUM
))
487 regcache_raw_collect (regcache
, regno
+ ARM_WR0_REGNUM
,
490 for (regno
= 0; regno
< 2; regno
++)
491 if (REG_VALID
== regcache_register_status (regcache
,
492 regno
+ ARM_WCSSF_REGNUM
))
493 regcache_raw_collect (regcache
, regno
+ ARM_WCSSF_REGNUM
,
494 ®buf
[16 * 8 + regno
* 4]);
496 for (regno
= 0; regno
< 4; regno
++)
497 if (REG_VALID
== regcache_register_status (regcache
,
498 regno
+ ARM_WCGR0_REGNUM
))
499 regcache_raw_collect (regcache
, regno
+ ARM_WCGR0_REGNUM
,
500 ®buf
[16 * 8 + 2 * 4 + regno
* 4]);
502 ret
= ptrace (PTRACE_SETWMMXREGS
, tid
, 0, regbuf
);
506 warning (_("Unable to store WMMX registers."));
511 /* Fetch and store VFP Registers. The kernel object has space for 32
512 64-bit registers, and the FPSCR. This is even when on a VFPv2 or
514 #define VFP_REGS_SIZE (32 * 8 + 4)
517 fetch_vfp_regs (struct regcache
*regcache
)
519 char regbuf
[VFP_REGS_SIZE
];
521 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
522 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
524 /* Get the thread id for the ptrace call. */
525 tid
= GET_THREAD_ID (inferior_ptid
);
527 ret
= ptrace (PTRACE_GETVFPREGS
, tid
, 0, regbuf
);
530 warning (_("Unable to fetch VFP registers."));
534 for (regno
= 0; regno
< tdep
->vfp_register_count
; regno
++)
535 regcache_raw_supply (regcache
, regno
+ ARM_D0_REGNUM
,
536 (char *) regbuf
+ regno
* 8);
538 regcache_raw_supply (regcache
, ARM_FPSCR_REGNUM
,
539 (char *) regbuf
+ 32 * 8);
543 store_vfp_regs (const struct regcache
*regcache
)
545 char regbuf
[VFP_REGS_SIZE
];
547 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
548 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
550 /* Get the thread id for the ptrace call. */
551 tid
= GET_THREAD_ID (inferior_ptid
);
553 ret
= ptrace (PTRACE_GETVFPREGS
, tid
, 0, regbuf
);
556 warning (_("Unable to fetch VFP registers (for update)."));
560 for (regno
= 0; regno
< tdep
->vfp_register_count
; regno
++)
561 regcache_raw_collect (regcache
, regno
+ ARM_D0_REGNUM
,
562 (char *) regbuf
+ regno
* 8);
564 regcache_raw_collect (regcache
, ARM_FPSCR_REGNUM
,
565 (char *) regbuf
+ 32 * 8);
567 ret
= ptrace (PTRACE_SETVFPREGS
, tid
, 0, regbuf
);
571 warning (_("Unable to store VFP registers."));
576 /* Fetch registers from the child process. Fetch all registers if
577 regno == -1, otherwise fetch all general registers or all floating
578 point registers depending upon the value of regno. */
581 arm_linux_fetch_inferior_registers (struct target_ops
*ops
,
582 struct regcache
*regcache
, int regno
)
584 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
585 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
589 fetch_regs (regcache
);
590 fetch_fpregs (regcache
);
591 if (tdep
->have_wmmx_registers
)
592 fetch_wmmx_regs (regcache
);
593 if (tdep
->vfp_register_count
> 0)
594 fetch_vfp_regs (regcache
);
598 if (regno
< ARM_F0_REGNUM
|| regno
== ARM_PS_REGNUM
)
599 fetch_register (regcache
, regno
);
600 else if (regno
>= ARM_F0_REGNUM
&& regno
<= ARM_FPS_REGNUM
)
601 fetch_fpregister (regcache
, regno
);
602 else if (tdep
->have_wmmx_registers
603 && regno
>= ARM_WR0_REGNUM
&& regno
<= ARM_WCGR7_REGNUM
)
604 fetch_wmmx_regs (regcache
);
605 else if (tdep
->vfp_register_count
> 0
606 && regno
>= ARM_D0_REGNUM
607 && regno
<= ARM_D0_REGNUM
+ tdep
->vfp_register_count
)
608 fetch_vfp_regs (regcache
);
612 /* Store registers back into the inferior. Store all registers if
613 regno == -1, otherwise store all general registers or all floating
614 point registers depending upon the value of regno. */
617 arm_linux_store_inferior_registers (struct target_ops
*ops
,
618 struct regcache
*regcache
, int regno
)
620 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
621 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
625 store_regs (regcache
);
626 store_fpregs (regcache
);
627 if (tdep
->have_wmmx_registers
)
628 store_wmmx_regs (regcache
);
629 if (tdep
->vfp_register_count
> 0)
630 store_vfp_regs (regcache
);
634 if (regno
< ARM_F0_REGNUM
|| regno
== ARM_PS_REGNUM
)
635 store_register (regcache
, regno
);
636 else if ((regno
>= ARM_F0_REGNUM
) && (regno
<= ARM_FPS_REGNUM
))
637 store_fpregister (regcache
, regno
);
638 else if (tdep
->have_wmmx_registers
639 && regno
>= ARM_WR0_REGNUM
&& regno
<= ARM_WCGR7_REGNUM
)
640 store_wmmx_regs (regcache
);
641 else if (tdep
->vfp_register_count
> 0
642 && regno
>= ARM_D0_REGNUM
643 && regno
<= ARM_D0_REGNUM
+ tdep
->vfp_register_count
)
644 store_vfp_regs (regcache
);
648 /* Wrapper functions for the standard regset handling, used by
652 fill_gregset (const struct regcache
*regcache
,
653 gdb_gregset_t
*gregsetp
, int regno
)
655 arm_linux_collect_gregset (NULL
, regcache
, regno
, gregsetp
, 0);
659 supply_gregset (struct regcache
*regcache
, const gdb_gregset_t
*gregsetp
)
661 arm_linux_supply_gregset (NULL
, regcache
, -1, gregsetp
, 0);
665 fill_fpregset (const struct regcache
*regcache
,
666 gdb_fpregset_t
*fpregsetp
, int regno
)
668 arm_linux_collect_nwfpe (NULL
, regcache
, regno
, fpregsetp
, 0);
671 /* Fill GDB's register array with the floating-point register values
675 supply_fpregset (struct regcache
*regcache
, const gdb_fpregset_t
*fpregsetp
)
677 arm_linux_supply_nwfpe (NULL
, regcache
, -1, fpregsetp
, 0);
680 /* Fetch the thread-local storage pointer for libthread_db. */
683 ps_get_thread_area (const struct ps_prochandle
*ph
,
684 lwpid_t lwpid
, int idx
, void **base
)
686 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
689 /* IDX is the bias from the thread pointer to the beginning of the
690 thread descriptor. It has to be subtracted due to implementation
691 quirks in libthread_db. */
692 *base
= (void *) ((char *)*base
- idx
);
697 static const struct target_desc
*
698 arm_linux_read_description (struct target_ops
*ops
)
700 CORE_ADDR arm_hwcap
= 0;
702 if (have_ptrace_getregset
== -1)
704 elf_gregset_t gpregs
;
706 int tid
= GET_THREAD_ID (inferior_ptid
);
708 iov
.iov_base
= &gpregs
;
709 iov
.iov_len
= sizeof (gpregs
);
711 /* Check if PTRACE_GETREGSET works. */
712 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) < 0)
713 have_ptrace_getregset
= 0;
715 have_ptrace_getregset
= 1;
718 if (target_auxv_search (ops
, AT_HWCAP
, &arm_hwcap
) != 1)
720 return ops
->beneath
->to_read_description (ops
->beneath
);
723 if (arm_hwcap
& HWCAP_IWMMXT
)
724 return tdesc_arm_with_iwmmxt
;
726 if (arm_hwcap
& HWCAP_VFP
)
730 const struct target_desc
* result
= NULL
;
732 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
733 Neon with VFPv3-D32. */
734 if (arm_hwcap
& HWCAP_NEON
)
735 result
= tdesc_arm_with_neon
;
736 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
737 result
= tdesc_arm_with_vfpv3
;
739 result
= tdesc_arm_with_vfpv2
;
741 /* Now make sure that the kernel supports reading these
742 registers. Support was added in 2.6.30. */
743 pid
= ptid_get_lwp (inferior_ptid
);
745 buf
= alloca (VFP_REGS_SIZE
);
746 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0
753 return ops
->beneath
->to_read_description (ops
->beneath
);
756 /* Information describing the hardware breakpoint capabilities. */
757 struct arm_linux_hwbp_cap
760 gdb_byte max_wp_length
;
765 /* Since we cannot dynamically allocate subfields of arm_linux_process_info,
766 assume a maximum number of supported break-/watchpoints. */
770 /* Get hold of the Hardware Breakpoint information for the target we are
771 attached to. Returns NULL if the kernel doesn't support Hardware
772 breakpoints at all, or a pointer to the information structure. */
773 static const struct arm_linux_hwbp_cap
*
774 arm_linux_get_hwbp_cap (void)
776 /* The info structure we return. */
777 static struct arm_linux_hwbp_cap info
;
779 /* Is INFO in a good state? -1 means that no attempt has been made to
780 initialize INFO; 0 means an attempt has been made, but it failed; 1
781 means INFO is in an initialized state. */
782 static int available
= -1;
789 tid
= GET_THREAD_ID (inferior_ptid
);
790 if (ptrace (PTRACE_GETHBPREGS
, tid
, 0, &val
) < 0)
794 info
.arch
= (gdb_byte
)((val
>> 24) & 0xff);
795 info
.max_wp_length
= (gdb_byte
)((val
>> 16) & 0xff);
796 info
.wp_count
= (gdb_byte
)((val
>> 8) & 0xff);
797 info
.bp_count
= (gdb_byte
)(val
& 0xff);
799 if (info
.wp_count
> MAX_WPTS
)
801 warning (_("arm-linux-gdb supports %d hardware watchpoints but target \
802 supports %d"), MAX_WPTS
, info
.wp_count
);
803 info
.wp_count
= MAX_WPTS
;
806 if (info
.bp_count
> MAX_BPTS
)
808 warning (_("arm-linux-gdb supports %d hardware breakpoints but target \
809 supports %d"), MAX_BPTS
, info
.bp_count
);
810 info
.bp_count
= MAX_BPTS
;
812 available
= (info
.arch
!= 0);
816 return available
== 1 ? &info
: NULL
;
819 /* How many hardware breakpoints are available? */
821 arm_linux_get_hw_breakpoint_count (void)
823 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
824 return cap
!= NULL
? cap
->bp_count
: 0;
827 /* How many hardware watchpoints are available? */
829 arm_linux_get_hw_watchpoint_count (void)
831 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
832 return cap
!= NULL
? cap
->wp_count
: 0;
835 /* Have we got a free break-/watch-point available for use? Returns -1 if
836 there is not an appropriate resource available, otherwise returns 1. */
838 arm_linux_can_use_hw_breakpoint (struct target_ops
*self
,
839 int type
, int cnt
, int ot
)
841 if (type
== bp_hardware_watchpoint
|| type
== bp_read_watchpoint
842 || type
== bp_access_watchpoint
|| type
== bp_watchpoint
)
844 int count
= arm_linux_get_hw_watchpoint_count ();
848 else if (cnt
+ ot
> count
)
851 else if (type
== bp_hardware_breakpoint
)
853 int count
= arm_linux_get_hw_breakpoint_count ();
857 else if (cnt
> count
)
866 /* Enum describing the different types of ARM hardware break-/watch-points. */
875 /* Type describing an ARM Hardware Breakpoint Control register value. */
876 typedef unsigned int arm_hwbp_control_t
;
878 /* Structure used to keep track of hardware break-/watch-points. */
879 struct arm_linux_hw_breakpoint
881 /* Address to break on, or being watched. */
882 unsigned int address
;
883 /* Control register for break-/watch- point. */
884 arm_hwbp_control_t control
;
887 /* Structure containing arrays of per process hardware break-/watchpoints
888 for caching address and control information.
890 The Linux ptrace interface to hardware break-/watch-points presents the
891 values in a vector centred around 0 (which is used fo generic information).
892 Positive indicies refer to breakpoint addresses/control registers, negative
893 indices to watchpoint addresses/control registers.
895 The Linux vector is indexed as follows:
896 -((i << 1) + 2): Control register for watchpoint i.
897 -((i << 1) + 1): Address register for watchpoint i.
898 0: Information register.
899 ((i << 1) + 1): Address register for breakpoint i.
900 ((i << 1) + 2): Control register for breakpoint i.
902 This structure is used as a per-thread cache of the state stored by the
903 kernel, so that we don't need to keep calling into the kernel to find a
906 We treat break-/watch-points with their enable bit clear as being deleted.
908 struct arm_linux_debug_reg_state
910 /* Hardware breakpoints for this process. */
911 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
912 /* Hardware watchpoints for this process. */
913 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
916 /* Per-process arch-specific data we want to keep. */
917 struct arm_linux_process_info
920 struct arm_linux_process_info
*next
;
921 /* The process identifier. */
923 /* Hardware break-/watchpoints state information. */
924 struct arm_linux_debug_reg_state state
;
928 /* Per-thread arch-specific data we want to keep. */
931 /* Non-zero if our copy differs from what's recorded in the thread. */
932 char bpts_changed
[MAX_BPTS
];
933 char wpts_changed
[MAX_WPTS
];
936 static struct arm_linux_process_info
*arm_linux_process_list
= NULL
;
938 /* Find process data for process PID. */
940 static struct arm_linux_process_info
*
941 arm_linux_find_process_pid (pid_t pid
)
943 struct arm_linux_process_info
*proc
;
945 for (proc
= arm_linux_process_list
; proc
; proc
= proc
->next
)
946 if (proc
->pid
== pid
)
952 /* Add process data for process PID. Returns newly allocated info
955 static struct arm_linux_process_info
*
956 arm_linux_add_process (pid_t pid
)
958 struct arm_linux_process_info
*proc
;
960 proc
= xcalloc (1, sizeof (*proc
));
963 proc
->next
= arm_linux_process_list
;
964 arm_linux_process_list
= proc
;
969 /* Get data specific info for process PID, creating it if necessary.
970 Never returns NULL. */
972 static struct arm_linux_process_info
*
973 arm_linux_process_info_get (pid_t pid
)
975 struct arm_linux_process_info
*proc
;
977 proc
= arm_linux_find_process_pid (pid
);
979 proc
= arm_linux_add_process (pid
);
984 /* Called whenever GDB is no longer debugging process PID. It deletes
985 data structures that keep track of debug register state. */
988 arm_linux_forget_process (pid_t pid
)
990 struct arm_linux_process_info
*proc
, **proc_link
;
992 proc
= arm_linux_process_list
;
993 proc_link
= &arm_linux_process_list
;
997 if (proc
->pid
== pid
)
999 *proc_link
= proc
->next
;
1005 proc_link
= &proc
->next
;
1010 /* Get hardware break-/watchpoint state for process PID. */
1012 static struct arm_linux_debug_reg_state
*
1013 arm_linux_get_debug_reg_state (pid_t pid
)
1015 return &arm_linux_process_info_get (pid
)->state
;
1018 /* Initialize an ARM hardware break-/watch-point control register value.
1019 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
1020 type of break-/watch-point; ENABLE indicates whether the point is enabled.
1022 static arm_hwbp_control_t
1023 arm_hwbp_control_initialize (unsigned byte_address_select
,
1024 arm_hwbp_type hwbp_type
,
1027 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
1028 gdb_assert (hwbp_type
!= arm_hwbp_break
1029 || ((byte_address_select
& 0xfU
) != 0));
1031 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
1034 /* Does the breakpoint control value CONTROL have the enable bit set? */
1036 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
1038 return control
& 0x1;
1041 /* Change a breakpoint control word so that it is in the disabled state. */
1042 static arm_hwbp_control_t
1043 arm_hwbp_control_disable (arm_hwbp_control_t control
)
1045 return control
& ~0x1;
1048 /* Initialise the hardware breakpoint structure P. The breakpoint will be
1049 enabled, and will point to the placed address of BP_TGT. */
1051 arm_linux_hw_breakpoint_initialize (struct gdbarch
*gdbarch
,
1052 struct bp_target_info
*bp_tgt
,
1053 struct arm_linux_hw_breakpoint
*p
)
1056 CORE_ADDR address
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
1058 /* We have to create a mask for the control register which says which bits
1059 of the word pointed to by address to break on. */
1060 if (arm_pc_is_thumb (gdbarch
, address
))
1071 p
->address
= (unsigned int) address
;
1072 p
->control
= arm_hwbp_control_initialize (mask
, arm_hwbp_break
, 1);
1075 /* Get the ARM hardware breakpoint type from the RW value we're given when
1076 asked to set a watchpoint. */
1077 static arm_hwbp_type
1078 arm_linux_get_hwbp_type (int rw
)
1081 return arm_hwbp_load
;
1082 else if (rw
== hw_write
)
1083 return arm_hwbp_store
;
1085 return arm_hwbp_access
;
1088 /* Initialize the hardware breakpoint structure P for a watchpoint at ADDR
1089 to LEN. The type of watchpoint is given in RW. */
1091 arm_linux_hw_watchpoint_initialize (CORE_ADDR addr
, int len
, int rw
,
1092 struct arm_linux_hw_breakpoint
*p
)
1094 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
1097 gdb_assert (cap
!= NULL
);
1098 gdb_assert (cap
->max_wp_length
!= 0);
1100 mask
= (1 << len
) - 1;
1102 p
->address
= (unsigned int) addr
;
1103 p
->control
= arm_hwbp_control_initialize (mask
,
1104 arm_linux_get_hwbp_type (rw
), 1);
1107 /* Are two break-/watch-points equal? */
1109 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
1110 const struct arm_linux_hw_breakpoint
*p2
)
1112 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
1115 /* Callback to mark a watch-/breakpoint to be updated in all threads of
1116 the current process. */
1118 struct update_registers_data
1125 update_registers_callback (struct lwp_info
*lwp
, void *arg
)
1127 struct update_registers_data
*data
= (struct update_registers_data
*) arg
;
1129 if (lwp
->arch_private
== NULL
)
1130 lwp
->arch_private
= XCNEW (struct arch_lwp_info
);
1132 /* The actual update is done later just before resuming the lwp,
1133 we just mark that the registers need updating. */
1135 lwp
->arch_private
->wpts_changed
[data
->index
] = 1;
1137 lwp
->arch_private
->bpts_changed
[data
->index
] = 1;
1139 /* If the lwp isn't stopped, force it to momentarily pause, so
1140 we can update its breakpoint registers. */
1142 linux_stop_lwp (lwp
);
1147 /* Insert the hardware breakpoint (WATCHPOINT = 0) or watchpoint (WATCHPOINT
1148 =1) BPT for thread TID. */
1150 arm_linux_insert_hw_breakpoint1 (const struct arm_linux_hw_breakpoint
* bpt
,
1156 struct arm_linux_hw_breakpoint
* bpts
;
1157 struct update_registers_data data
;
1159 pid
= ptid_get_pid (inferior_ptid
);
1160 pid_ptid
= pid_to_ptid (pid
);
1164 count
= arm_linux_get_hw_watchpoint_count ();
1165 bpts
= arm_linux_get_debug_reg_state (pid
)->wpts
;
1169 count
= arm_linux_get_hw_breakpoint_count ();
1170 bpts
= arm_linux_get_debug_reg_state (pid
)->bpts
;
1173 for (i
= 0; i
< count
; ++i
)
1174 if (!arm_hwbp_control_is_enabled (bpts
[i
].control
))
1176 data
.watch
= watchpoint
;
1179 iterate_over_lwps (pid_ptid
, update_registers_callback
, &data
);
1183 gdb_assert (i
!= count
);
1186 /* Remove the hardware breakpoint (WATCHPOINT = 0) or watchpoint
1187 (WATCHPOINT = 1) BPT for thread TID. */
1189 arm_linux_remove_hw_breakpoint1 (const struct arm_linux_hw_breakpoint
*bpt
,
1195 struct arm_linux_hw_breakpoint
* bpts
;
1196 struct update_registers_data data
;
1198 pid
= ptid_get_pid (inferior_ptid
);
1199 pid_ptid
= pid_to_ptid (pid
);
1203 count
= arm_linux_get_hw_watchpoint_count ();
1204 bpts
= arm_linux_get_debug_reg_state (pid
)->wpts
;
1208 count
= arm_linux_get_hw_breakpoint_count ();
1209 bpts
= arm_linux_get_debug_reg_state (pid
)->bpts
;
1212 for (i
= 0; i
< count
; ++i
)
1213 if (arm_linux_hw_breakpoint_equal (bpt
, bpts
+ i
))
1215 data
.watch
= watchpoint
;
1217 bpts
[i
].control
= arm_hwbp_control_disable (bpts
[i
].control
);
1218 iterate_over_lwps (pid_ptid
, update_registers_callback
, &data
);
1222 gdb_assert (i
!= count
);
1225 /* Insert a Hardware breakpoint. */
1227 arm_linux_insert_hw_breakpoint (struct target_ops
*self
,
1228 struct gdbarch
*gdbarch
,
1229 struct bp_target_info
*bp_tgt
)
1231 struct lwp_info
*lp
;
1232 struct arm_linux_hw_breakpoint p
;
1234 if (arm_linux_get_hw_breakpoint_count () == 0)
1237 arm_linux_hw_breakpoint_initialize (gdbarch
, bp_tgt
, &p
);
1239 arm_linux_insert_hw_breakpoint1 (&p
, 0);
1244 /* Remove a hardware breakpoint. */
1246 arm_linux_remove_hw_breakpoint (struct target_ops
*self
,
1247 struct gdbarch
*gdbarch
,
1248 struct bp_target_info
*bp_tgt
)
1250 struct lwp_info
*lp
;
1251 struct arm_linux_hw_breakpoint p
;
1253 if (arm_linux_get_hw_breakpoint_count () == 0)
1256 arm_linux_hw_breakpoint_initialize (gdbarch
, bp_tgt
, &p
);
1258 arm_linux_remove_hw_breakpoint1 (&p
, 0);
1263 /* Are we able to use a hardware watchpoint for the LEN bytes starting at
1266 arm_linux_region_ok_for_hw_watchpoint (struct target_ops
*self
,
1267 CORE_ADDR addr
, int len
)
1269 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
1270 CORE_ADDR max_wp_length
, aligned_addr
;
1272 /* Can not set watchpoints for zero or negative lengths. */
1276 /* Need to be able to use the ptrace interface. */
1277 if (cap
== NULL
|| cap
->wp_count
== 0)
1280 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
1281 range covered by a watchpoint. */
1282 max_wp_length
= (CORE_ADDR
)cap
->max_wp_length
;
1283 aligned_addr
= addr
& ~(max_wp_length
- 1);
1285 if (aligned_addr
+ max_wp_length
< addr
+ len
)
1288 /* The current ptrace interface can only handle watchpoints that are a
1290 if ((len
& (len
- 1)) != 0)
1293 /* All tests passed so we must be able to set a watchpoint. */
1297 /* Insert a Hardware breakpoint. */
1299 arm_linux_insert_watchpoint (struct target_ops
*self
,
1300 CORE_ADDR addr
, int len
, int rw
,
1301 struct expression
*cond
)
1303 struct lwp_info
*lp
;
1304 struct arm_linux_hw_breakpoint p
;
1306 if (arm_linux_get_hw_watchpoint_count () == 0)
1309 arm_linux_hw_watchpoint_initialize (addr
, len
, rw
, &p
);
1311 arm_linux_insert_hw_breakpoint1 (&p
, 1);
1316 /* Remove a hardware breakpoint. */
1318 arm_linux_remove_watchpoint (struct target_ops
*self
,
1319 CORE_ADDR addr
, int len
, int rw
,
1320 struct expression
*cond
)
1322 struct lwp_info
*lp
;
1323 struct arm_linux_hw_breakpoint p
;
1325 if (arm_linux_get_hw_watchpoint_count () == 0)
1328 arm_linux_hw_watchpoint_initialize (addr
, len
, rw
, &p
);
1330 arm_linux_remove_hw_breakpoint1 (&p
, 1);
1335 /* What was the data address the target was stopped on accessing. */
1337 arm_linux_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
1342 if (!linux_nat_get_siginfo (inferior_ptid
, &siginfo
))
1345 /* This must be a hardware breakpoint. */
1346 if (siginfo
.si_signo
!= SIGTRAP
1347 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
1350 /* We must be able to set hardware watchpoints. */
1351 if (arm_linux_get_hw_watchpoint_count () == 0)
1354 slot
= siginfo
.si_errno
;
1356 /* If we are in a positive slot then we're looking at a breakpoint and not
1361 *addr_p
= (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
1365 /* Has the target been stopped by hitting a watchpoint? */
1367 arm_linux_stopped_by_watchpoint (struct target_ops
*ops
)
1370 return arm_linux_stopped_data_address (ops
, &addr
);
1374 arm_linux_watchpoint_addr_within_range (struct target_ops
*target
,
1376 CORE_ADDR start
, int length
)
1378 return start
<= addr
&& start
+ length
- 1 >= addr
;
1381 /* Handle thread creation. We need to copy the breakpoints and watchpoints
1382 in the parent thread to the child thread. */
1384 arm_linux_new_thread (struct lwp_info
*lp
)
1387 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
1389 /* Mark that all the hardware breakpoint/watchpoint register pairs
1390 for this thread need to be initialized. */
1392 for (i
= 0; i
< MAX_BPTS
; i
++)
1394 info
->bpts_changed
[i
] = 1;
1395 info
->wpts_changed
[i
] = 1;
1398 lp
->arch_private
= info
;
1401 /* Called when resuming a thread.
1402 The hardware debug registers are updated when there is any change. */
1405 arm_linux_prepare_to_resume (struct lwp_info
*lwp
)
1408 struct arm_linux_hw_breakpoint
*bpts
, *wpts
;
1409 struct arch_lwp_info
*arm_lwp_info
= lwp
->arch_private
;
1411 pid
= ptid_get_lwp (lwp
->ptid
);
1412 bpts
= arm_linux_get_debug_reg_state (ptid_get_pid (lwp
->ptid
))->bpts
;
1413 wpts
= arm_linux_get_debug_reg_state (ptid_get_pid (lwp
->ptid
))->wpts
;
1415 /* NULL means this is the main thread still going through the shell,
1416 or, no watchpoint has been set yet. In that case, there's
1418 if (arm_lwp_info
== NULL
)
1421 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
1422 if (arm_lwp_info
->bpts_changed
[i
])
1425 if (arm_hwbp_control_is_enabled (bpts
[i
].control
))
1426 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1427 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1), &bpts
[i
].address
) < 0)
1428 perror_with_name (_("Unexpected error setting breakpoint"));
1430 if (bpts
[i
].control
!= 0)
1431 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1432 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2), &bpts
[i
].control
) < 0)
1433 perror_with_name (_("Unexpected error setting breakpoint"));
1435 arm_lwp_info
->bpts_changed
[i
] = 0;
1438 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
1439 if (arm_lwp_info
->wpts_changed
[i
])
1442 if (arm_hwbp_control_is_enabled (wpts
[i
].control
))
1443 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1444 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1), &wpts
[i
].address
) < 0)
1445 perror_with_name (_("Unexpected error setting watchpoint"));
1447 if (wpts
[i
].control
!= 0)
1448 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1449 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2), &wpts
[i
].control
) < 0)
1450 perror_with_name (_("Unexpected error setting watchpoint"));
1452 arm_lwp_info
->wpts_changed
[i
] = 0;
1456 /* linux_nat_new_fork hook. */
1459 arm_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
1462 struct arm_linux_debug_reg_state
*parent_state
;
1463 struct arm_linux_debug_reg_state
*child_state
;
1465 /* NULL means no watchpoint has ever been set in the parent. In
1466 that case, there's nothing to do. */
1467 if (parent
->arch_private
== NULL
)
1470 /* GDB core assumes the child inherits the watchpoints/hw
1471 breakpoints of the parent, and will remove them all from the
1472 forked off process. Copy the debug registers mirrors into the
1473 new process so that all breakpoints and watchpoints can be
1474 removed together. */
1476 parent_pid
= ptid_get_pid (parent
->ptid
);
1477 parent_state
= arm_linux_get_debug_reg_state (parent_pid
);
1478 child_state
= arm_linux_get_debug_reg_state (child_pid
);
1479 *child_state
= *parent_state
;
1482 void _initialize_arm_linux_nat (void);
1485 _initialize_arm_linux_nat (void)
1487 struct target_ops
*t
;
1489 /* Fill in the generic GNU/Linux methods. */
1490 t
= linux_target ();
1492 /* Add our register access methods. */
1493 t
->to_fetch_registers
= arm_linux_fetch_inferior_registers
;
1494 t
->to_store_registers
= arm_linux_store_inferior_registers
;
1496 /* Add our hardware breakpoint and watchpoint implementation. */
1497 t
->to_can_use_hw_breakpoint
= arm_linux_can_use_hw_breakpoint
;
1498 t
->to_insert_hw_breakpoint
= arm_linux_insert_hw_breakpoint
;
1499 t
->to_remove_hw_breakpoint
= arm_linux_remove_hw_breakpoint
;
1500 t
->to_region_ok_for_hw_watchpoint
= arm_linux_region_ok_for_hw_watchpoint
;
1501 t
->to_insert_watchpoint
= arm_linux_insert_watchpoint
;
1502 t
->to_remove_watchpoint
= arm_linux_remove_watchpoint
;
1503 t
->to_stopped_by_watchpoint
= arm_linux_stopped_by_watchpoint
;
1504 t
->to_stopped_data_address
= arm_linux_stopped_data_address
;
1505 t
->to_watchpoint_addr_within_range
= arm_linux_watchpoint_addr_within_range
;
1507 t
->to_read_description
= arm_linux_read_description
;
1509 /* Register the target. */
1510 linux_nat_add_target (t
);
1512 /* Handle thread creation and exit. */
1513 linux_nat_set_new_thread (t
, arm_linux_new_thread
);
1514 linux_nat_set_prepare_to_resume (t
, arm_linux_prepare_to_resume
);
1516 /* Handle process creation and exit. */
1517 linux_nat_set_new_fork (t
, arm_linux_new_fork
);
1518 linux_nat_set_forget_process (t
, arm_linux_forget_process
);