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 /* A flag for whether the WMMX registers are available. */
65 static int arm_linux_has_wmmx_registers;
67 extern int arm_apcs_32;
69 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
70 case we may be tracing more than one process at a time. In that
71 case, inferior_ptid will contain the main process ID and the
72 individual thread (process) ID. get_thread_id () is used to get
73 the thread id if it's available, and the process id otherwise. */
76 get_thread_id (ptid_t ptid)
78 int tid = ptid_get_lwp (ptid);
80 tid = ptid_get_pid (ptid);
84 #define GET_THREAD_ID(PTID) get_thread_id (PTID)
86 /* Get the value of a particular register from the floating point
87 state of the process and store it into regcache. */
90 fetch_fpregister (struct regcache *regcache, int regno)
93 gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
95 /* Get the thread id for the ptrace call. */
96 tid = GET_THREAD_ID (inferior_ptid);
98 /* Read the floating point state. */
99 ret = ptrace (PT_GETFPREGS, tid, 0, fp);
102 warning (_("Unable to fetch floating point register."));
107 if (ARM_FPS_REGNUM == regno)
108 regcache_raw_supply (regcache, ARM_FPS_REGNUM,
109 fp + NWFPE_FPSR_OFFSET);
111 /* Fetch the floating point register. */
112 if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
113 supply_nwfpe_register (regcache, regno, fp);
116 /* Get the whole floating point state of the process and store it
120 fetch_fpregs (struct regcache *regcache)
123 gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
125 /* Get the thread id for the ptrace call. */
126 tid = GET_THREAD_ID (inferior_ptid);
128 /* Read the floating point state. */
129 ret = ptrace (PT_GETFPREGS, tid, 0, fp);
132 warning (_("Unable to fetch the floating point registers."));
137 regcache_raw_supply (regcache, ARM_FPS_REGNUM,
138 fp + NWFPE_FPSR_OFFSET);
140 /* Fetch the floating point registers. */
141 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
142 supply_nwfpe_register (regcache, regno, fp);
145 /* Save a particular register into the floating point state of the
146 process using the contents from regcache. */
149 store_fpregister (const struct regcache *regcache, int regno)
152 gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
154 /* Get the thread id for the ptrace call. */
155 tid = GET_THREAD_ID (inferior_ptid);
157 /* Read the floating point state. */
158 ret = ptrace (PT_GETFPREGS, tid, 0, fp);
161 warning (_("Unable to fetch the floating point registers."));
166 if (ARM_FPS_REGNUM == regno
167 && REG_VALID == regcache_register_status (regcache, ARM_FPS_REGNUM))
168 regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
170 /* Store the floating point register. */
171 if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
172 collect_nwfpe_register (regcache, regno, fp);
174 ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
177 warning (_("Unable to store floating point register."));
182 /* Save the whole floating point state of the process using
183 the contents from regcache. */
186 store_fpregs (const struct regcache *regcache)
189 gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
191 /* Get the thread id for the ptrace call. */
192 tid = GET_THREAD_ID (inferior_ptid);
194 /* Read the floating point state. */
195 ret = ptrace (PT_GETFPREGS, tid, 0, fp);
198 warning (_("Unable to fetch the floating point registers."));
203 if (REG_VALID == regcache_register_status (regcache, ARM_FPS_REGNUM))
204 regcache_raw_collect (regcache, ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
206 /* Store the floating point registers. */
207 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
208 if (REG_VALID == regcache_register_status (regcache, regno))
209 collect_nwfpe_register (regcache, regno, fp);
211 ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
214 warning (_("Unable to store floating point registers."));
219 /* Fetch a general register of the process and store into
223 fetch_register (struct regcache *regcache, int regno)
228 /* Get the thread id for the ptrace call. */
229 tid = GET_THREAD_ID (inferior_ptid);
231 ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
234 warning (_("Unable to fetch general register."));
238 if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM)
239 regcache_raw_supply (regcache, regno, (char *) ®s[regno]);
241 if (ARM_PS_REGNUM == regno)
244 regcache_raw_supply (regcache, ARM_PS_REGNUM,
245 (char *) ®s[ARM_CPSR_GREGNUM]);
247 regcache_raw_supply (regcache, ARM_PS_REGNUM,
248 (char *) ®s[ARM_PC_REGNUM]);
251 if (ARM_PC_REGNUM == regno)
253 regs[ARM_PC_REGNUM] = gdbarch_addr_bits_remove
254 (get_regcache_arch (regcache),
255 regs[ARM_PC_REGNUM]);
256 regcache_raw_supply (regcache, ARM_PC_REGNUM,
257 (char *) ®s[ARM_PC_REGNUM]);
261 /* Fetch all general registers of the process and store into
265 fetch_regs (struct regcache *regcache)
270 /* Get the thread id for the ptrace call. */
271 tid = GET_THREAD_ID (inferior_ptid);
273 ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
276 warning (_("Unable to fetch general registers."));
280 for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
281 regcache_raw_supply (regcache, regno, (char *) ®s[regno]);
284 regcache_raw_supply (regcache, ARM_PS_REGNUM,
285 (char *) ®s[ARM_CPSR_GREGNUM]);
287 regcache_raw_supply (regcache, ARM_PS_REGNUM,
288 (char *) ®s[ARM_PC_REGNUM]);
290 regs[ARM_PC_REGNUM] = gdbarch_addr_bits_remove
291 (get_regcache_arch (regcache), regs[ARM_PC_REGNUM]);
292 regcache_raw_supply (regcache, ARM_PC_REGNUM,
293 (char *) ®s[ARM_PC_REGNUM]);
296 /* Store all general registers of the process from the values in
300 store_register (const struct regcache *regcache, int regno)
305 if (REG_VALID != regcache_register_status (regcache, regno))
308 /* Get the thread id for the ptrace call. */
309 tid = GET_THREAD_ID (inferior_ptid);
311 /* Get the general registers from the process. */
312 ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
315 warning (_("Unable to fetch general registers."));
319 if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
320 regcache_raw_collect (regcache, regno, (char *) ®s[regno]);
321 else if (arm_apcs_32 && regno == ARM_PS_REGNUM)
322 regcache_raw_collect (regcache, regno,
323 (char *) ®s[ARM_CPSR_GREGNUM]);
324 else if (!arm_apcs_32 && regno == ARM_PS_REGNUM)
325 regcache_raw_collect (regcache, ARM_PC_REGNUM,
326 (char *) ®s[ARM_PC_REGNUM]);
328 ret = ptrace (PTRACE_SETREGS, tid, 0, ®s);
331 warning (_("Unable to store general register."));
337 store_regs (const struct regcache *regcache)
342 /* Get the thread id for the ptrace call. */
343 tid = GET_THREAD_ID (inferior_ptid);
345 /* Fetch the general registers. */
346 ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
349 warning (_("Unable to fetch general registers."));
353 for (regno = ARM_A1_REGNUM; regno <= ARM_PC_REGNUM; regno++)
355 if (REG_VALID == regcache_register_status (regcache, regno))
356 regcache_raw_collect (regcache, regno, (char *) ®s[regno]);
359 if (arm_apcs_32 && REG_VALID == regcache_register_status (regcache, ARM_PS_REGNUM))
360 regcache_raw_collect (regcache, ARM_PS_REGNUM,
361 (char *) ®s[ARM_CPSR_GREGNUM]);
363 ret = ptrace (PTRACE_SETREGS, tid, 0, ®s);
367 warning (_("Unable to store general registers."));
372 /* Fetch all WMMX registers of the process and store into
375 #define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
378 fetch_wmmx_regs (struct regcache *regcache)
380 char regbuf[IWMMXT_REGS_SIZE];
383 /* Get the thread id for the ptrace call. */
384 tid = GET_THREAD_ID (inferior_ptid);
386 ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
389 warning (_("Unable to fetch WMMX registers."));
393 for (regno = 0; regno < 16; regno++)
394 regcache_raw_supply (regcache, regno + ARM_WR0_REGNUM,
397 for (regno = 0; regno < 2; regno++)
398 regcache_raw_supply (regcache, regno + ARM_WCSSF_REGNUM,
399 ®buf[16 * 8 + regno * 4]);
401 for (regno = 0; regno < 4; regno++)
402 regcache_raw_supply (regcache, regno + ARM_WCGR0_REGNUM,
403 ®buf[16 * 8 + 2 * 4 + regno * 4]);
407 store_wmmx_regs (const struct regcache *regcache)
409 char regbuf[IWMMXT_REGS_SIZE];
412 /* Get the thread id for the ptrace call. */
413 tid = GET_THREAD_ID (inferior_ptid);
415 ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
418 warning (_("Unable to fetch WMMX registers."));
422 for (regno = 0; regno < 16; regno++)
423 if (REG_VALID == regcache_register_status (regcache,
424 regno + ARM_WR0_REGNUM))
425 regcache_raw_collect (regcache, regno + ARM_WR0_REGNUM,
428 for (regno = 0; regno < 2; regno++)
429 if (REG_VALID == regcache_register_status (regcache,
430 regno + ARM_WCSSF_REGNUM))
431 regcache_raw_collect (regcache, regno + ARM_WCSSF_REGNUM,
432 ®buf[16 * 8 + regno * 4]);
434 for (regno = 0; regno < 4; regno++)
435 if (REG_VALID == regcache_register_status (regcache,
436 regno + ARM_WCGR0_REGNUM))
437 regcache_raw_collect (regcache, regno + ARM_WCGR0_REGNUM,
438 ®buf[16 * 8 + 2 * 4 + regno * 4]);
440 ret = ptrace (PTRACE_SETWMMXREGS, tid, 0, regbuf);
444 warning (_("Unable to store WMMX registers."));
449 /* Fetch and store VFP Registers. The kernel object has space for 32
450 64-bit registers, and the FPSCR. This is even when on a VFPv2 or
452 #define VFP_REGS_SIZE (32 * 8 + 4)
455 fetch_vfp_regs (struct regcache *regcache)
457 char regbuf[VFP_REGS_SIZE];
459 struct gdbarch *gdbarch = get_regcache_arch (regcache);
460 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
462 /* Get the thread id for the ptrace call. */
463 tid = GET_THREAD_ID (inferior_ptid);
465 ret = ptrace (PTRACE_GETVFPREGS, tid, 0, regbuf);
468 warning (_("Unable to fetch VFP registers."));
472 for (regno = 0; regno < tdep->vfp_register_count; regno++)
473 regcache_raw_supply (regcache, regno + ARM_D0_REGNUM,
474 (char *) regbuf + regno * 8);
476 regcache_raw_supply (regcache, ARM_FPSCR_REGNUM,
477 (char *) regbuf + 32 * 8);
481 store_vfp_regs (const struct regcache *regcache)
483 char regbuf[VFP_REGS_SIZE];
485 struct gdbarch *gdbarch = get_regcache_arch (regcache);
486 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
488 /* Get the thread id for the ptrace call. */
489 tid = GET_THREAD_ID (inferior_ptid);
491 ret = ptrace (PTRACE_GETVFPREGS, tid, 0, regbuf);
494 warning (_("Unable to fetch VFP registers (for update)."));
498 for (regno = 0; regno < tdep->vfp_register_count; regno++)
499 regcache_raw_collect (regcache, regno + ARM_D0_REGNUM,
500 (char *) regbuf + regno * 8);
502 regcache_raw_collect (regcache, ARM_FPSCR_REGNUM,
503 (char *) regbuf + 32 * 8);
505 ret = ptrace (PTRACE_SETVFPREGS, tid, 0, regbuf);
509 warning (_("Unable to store VFP registers."));
514 /* Fetch registers from the child process. Fetch all registers if
515 regno == -1, otherwise fetch all general registers or all floating
516 point registers depending upon the value of regno. */
519 arm_linux_fetch_inferior_registers (struct target_ops *ops,
520 struct regcache *regcache, int regno)
522 struct gdbarch *gdbarch = get_regcache_arch (regcache);
523 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
527 fetch_regs (regcache);
528 fetch_fpregs (regcache);
529 if (arm_linux_has_wmmx_registers)
530 fetch_wmmx_regs (regcache);
531 if (tdep->vfp_register_count > 0)
532 fetch_vfp_regs (regcache);
536 if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
537 fetch_register (regcache, regno);
538 else if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
539 fetch_fpregister (regcache, regno);
540 else if (arm_linux_has_wmmx_registers
541 && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
542 fetch_wmmx_regs (regcache);
543 else if (tdep->vfp_register_count > 0
544 && regno >= ARM_D0_REGNUM
545 && regno <= ARM_D0_REGNUM + tdep->vfp_register_count)
546 fetch_vfp_regs (regcache);
550 /* Store registers back into the inferior. Store all registers if
551 regno == -1, otherwise store all general registers or all floating
552 point registers depending upon the value of regno. */
555 arm_linux_store_inferior_registers (struct target_ops *ops,
556 struct regcache *regcache, int regno)
558 struct gdbarch *gdbarch = get_regcache_arch (regcache);
559 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
563 store_regs (regcache);
564 store_fpregs (regcache);
565 if (arm_linux_has_wmmx_registers)
566 store_wmmx_regs (regcache);
567 if (tdep->vfp_register_count > 0)
568 store_vfp_regs (regcache);
572 if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
573 store_register (regcache, regno);
574 else if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
575 store_fpregister (regcache, regno);
576 else if (arm_linux_has_wmmx_registers
577 && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
578 store_wmmx_regs (regcache);
579 else if (tdep->vfp_register_count > 0
580 && regno >= ARM_D0_REGNUM
581 && regno <= ARM_D0_REGNUM + tdep->vfp_register_count)
582 store_vfp_regs (regcache);
586 /* Wrapper functions for the standard regset handling, used by
590 fill_gregset (const struct regcache *regcache,
591 gdb_gregset_t *gregsetp, int regno)
593 arm_linux_collect_gregset (NULL, regcache, regno, gregsetp, 0);
597 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
599 arm_linux_supply_gregset (NULL, regcache, -1, gregsetp, 0);
603 fill_fpregset (const struct regcache *regcache,
604 gdb_fpregset_t *fpregsetp, int regno)
606 arm_linux_collect_nwfpe (NULL, regcache, regno, fpregsetp, 0);
609 /* Fill GDB's register array with the floating-point register values
613 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
615 arm_linux_supply_nwfpe (NULL, regcache, -1, fpregsetp, 0);
618 /* Fetch the thread-local storage pointer for libthread_db. */
621 ps_get_thread_area (const struct ps_prochandle *ph,
622 lwpid_t lwpid, int idx, void **base)
624 if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
627 /* IDX is the bias from the thread pointer to the beginning of the
628 thread descriptor. It has to be subtracted due to implementation
629 quirks in libthread_db. */
630 *base = (void *) ((char *)*base - idx);
635 static const struct target_desc *
636 arm_linux_read_description (struct target_ops *ops)
638 CORE_ADDR arm_hwcap = 0;
639 arm_linux_has_wmmx_registers = 0;
641 if (target_auxv_search (ops, AT_HWCAP, &arm_hwcap) != 1)
643 return ops->beneath->to_read_description (ops->beneath);
646 if (arm_hwcap & HWCAP_IWMMXT)
648 arm_linux_has_wmmx_registers = 1;
649 return tdesc_arm_with_iwmmxt;
652 if (arm_hwcap & HWCAP_VFP)
656 const struct target_desc * result = NULL;
658 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
659 Neon with VFPv3-D32. */
660 if (arm_hwcap & HWCAP_NEON)
661 result = tdesc_arm_with_neon;
662 else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
663 result = tdesc_arm_with_vfpv3;
665 result = tdesc_arm_with_vfpv2;
667 /* Now make sure that the kernel supports reading these
668 registers. Support was added in 2.6.30. */
669 pid = ptid_get_lwp (inferior_ptid);
671 buf = alloca (VFP_REGS_SIZE);
672 if (ptrace (PTRACE_GETVFPREGS, pid, 0, buf) < 0
679 return ops->beneath->to_read_description (ops->beneath);
682 /* Information describing the hardware breakpoint capabilities. */
683 struct arm_linux_hwbp_cap
686 gdb_byte max_wp_length;
691 /* Since we cannot dynamically allocate subfields of arm_linux_process_info,
692 assume a maximum number of supported break-/watchpoints. */
696 /* Get hold of the Hardware Breakpoint information for the target we are
697 attached to. Returns NULL if the kernel doesn't support Hardware
698 breakpoints at all, or a pointer to the information structure. */
699 static const struct arm_linux_hwbp_cap *
700 arm_linux_get_hwbp_cap (void)
702 /* The info structure we return. */
703 static struct arm_linux_hwbp_cap info;
705 /* Is INFO in a good state? -1 means that no attempt has been made to
706 initialize INFO; 0 means an attempt has been made, but it failed; 1
707 means INFO is in an initialized state. */
708 static int available = -1;
715 tid = GET_THREAD_ID (inferior_ptid);
716 if (ptrace (PTRACE_GETHBPREGS, tid, 0, &val) < 0)
720 info.arch = (gdb_byte)((val >> 24) & 0xff);
721 info.max_wp_length = (gdb_byte)((val >> 16) & 0xff);
722 info.wp_count = (gdb_byte)((val >> 8) & 0xff);
723 info.bp_count = (gdb_byte)(val & 0xff);
725 if (info.wp_count > MAX_WPTS)
727 warning (_("arm-linux-gdb supports %d hardware watchpoints but target \
728 supports %d"), MAX_WPTS, info.wp_count);
729 info.wp_count = MAX_WPTS;
732 if (info.bp_count > MAX_BPTS)
734 warning (_("arm-linux-gdb supports %d hardware breakpoints but target \
735 supports %d"), MAX_BPTS, info.bp_count);
736 info.bp_count = MAX_BPTS;
738 available = (info.arch != 0);
742 return available == 1 ? &info : NULL;
745 /* How many hardware breakpoints are available? */
747 arm_linux_get_hw_breakpoint_count (void)
749 const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
750 return cap != NULL ? cap->bp_count : 0;
753 /* How many hardware watchpoints are available? */
755 arm_linux_get_hw_watchpoint_count (void)
757 const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
758 return cap != NULL ? cap->wp_count : 0;
761 /* Have we got a free break-/watch-point available for use? Returns -1 if
762 there is not an appropriate resource available, otherwise returns 1. */
764 arm_linux_can_use_hw_breakpoint (struct target_ops *self,
765 int type, int cnt, int ot)
767 if (type == bp_hardware_watchpoint || type == bp_read_watchpoint
768 || type == bp_access_watchpoint || type == bp_watchpoint)
770 int count = arm_linux_get_hw_watchpoint_count ();
774 else if (cnt + ot > count)
777 else if (type == bp_hardware_breakpoint)
779 int count = arm_linux_get_hw_breakpoint_count ();
783 else if (cnt > count)
792 /* Enum describing the different types of ARM hardware break-/watch-points. */
801 /* Type describing an ARM Hardware Breakpoint Control register value. */
802 typedef unsigned int arm_hwbp_control_t;
804 /* Structure used to keep track of hardware break-/watch-points. */
805 struct arm_linux_hw_breakpoint
807 /* Address to break on, or being watched. */
808 unsigned int address;
809 /* Control register for break-/watch- point. */
810 arm_hwbp_control_t control;
813 /* Structure containing arrays of per process hardware break-/watchpoints
814 for caching address and control information.
816 The Linux ptrace interface to hardware break-/watch-points presents the
817 values in a vector centred around 0 (which is used fo generic information).
818 Positive indicies refer to breakpoint addresses/control registers, negative
819 indices to watchpoint addresses/control registers.
821 The Linux vector is indexed as follows:
822 -((i << 1) + 2): Control register for watchpoint i.
823 -((i << 1) + 1): Address register for watchpoint i.
824 0: Information register.
825 ((i << 1) + 1): Address register for breakpoint i.
826 ((i << 1) + 2): Control register for breakpoint i.
828 This structure is used as a per-thread cache of the state stored by the
829 kernel, so that we don't need to keep calling into the kernel to find a
832 We treat break-/watch-points with their enable bit clear as being deleted.
834 struct arm_linux_debug_reg_state
836 /* Hardware breakpoints for this process. */
837 struct arm_linux_hw_breakpoint bpts[MAX_BPTS];
838 /* Hardware watchpoints for this process. */
839 struct arm_linux_hw_breakpoint wpts[MAX_WPTS];
842 /* Per-process arch-specific data we want to keep. */
843 struct arm_linux_process_info
846 struct arm_linux_process_info *next;
847 /* The process identifier. */
849 /* Hardware break-/watchpoints state information. */
850 struct arm_linux_debug_reg_state state;
854 /* Per-thread arch-specific data we want to keep. */
857 /* Non-zero if our copy differs from what's recorded in the thread. */
858 char bpts_changed[MAX_BPTS];
859 char wpts_changed[MAX_WPTS];
862 static struct arm_linux_process_info *arm_linux_process_list = NULL;
864 /* Find process data for process PID. */
866 static struct arm_linux_process_info *
867 arm_linux_find_process_pid (pid_t pid)
869 struct arm_linux_process_info *proc;
871 for (proc = arm_linux_process_list; proc; proc = proc->next)
872 if (proc->pid == pid)
878 /* Add process data for process PID. Returns newly allocated info
881 static struct arm_linux_process_info *
882 arm_linux_add_process (pid_t pid)
884 struct arm_linux_process_info *proc;
886 proc = xcalloc (1, sizeof (*proc));
889 proc->next = arm_linux_process_list;
890 arm_linux_process_list = proc;
895 /* Get data specific info for process PID, creating it if necessary.
896 Never returns NULL. */
898 static struct arm_linux_process_info *
899 arm_linux_process_info_get (pid_t pid)
901 struct arm_linux_process_info *proc;
903 proc = arm_linux_find_process_pid (pid);
905 proc = arm_linux_add_process (pid);
910 /* Called whenever GDB is no longer debugging process PID. It deletes
911 data structures that keep track of debug register state. */
914 arm_linux_forget_process (pid_t pid)
916 struct arm_linux_process_info *proc, **proc_link;
918 proc = arm_linux_process_list;
919 proc_link = &arm_linux_process_list;
923 if (proc->pid == pid)
925 *proc_link = proc->next;
931 proc_link = &proc->next;
936 /* Get hardware break-/watchpoint state for process PID. */
938 static struct arm_linux_debug_reg_state *
939 arm_linux_get_debug_reg_state (pid_t pid)
941 return &arm_linux_process_info_get (pid)->state;
944 /* Initialize an ARM hardware break-/watch-point control register value.
945 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
946 type of break-/watch-point; ENABLE indicates whether the point is enabled.
948 static arm_hwbp_control_t
949 arm_hwbp_control_initialize (unsigned byte_address_select,
950 arm_hwbp_type hwbp_type,
953 gdb_assert ((byte_address_select & ~0xffU) == 0);
954 gdb_assert (hwbp_type != arm_hwbp_break
955 || ((byte_address_select & 0xfU) != 0));
957 return (byte_address_select << 5) | (hwbp_type << 3) | (3 << 1) | enable;
960 /* Does the breakpoint control value CONTROL have the enable bit set? */
962 arm_hwbp_control_is_enabled (arm_hwbp_control_t control)
964 return control & 0x1;
967 /* Change a breakpoint control word so that it is in the disabled state. */
968 static arm_hwbp_control_t
969 arm_hwbp_control_disable (arm_hwbp_control_t control)
971 return control & ~0x1;
974 /* Initialise the hardware breakpoint structure P. The breakpoint will be
975 enabled, and will point to the placed address of BP_TGT. */
977 arm_linux_hw_breakpoint_initialize (struct gdbarch *gdbarch,
978 struct bp_target_info *bp_tgt,
979 struct arm_linux_hw_breakpoint *p)
982 CORE_ADDR address = bp_tgt->placed_address = bp_tgt->reqstd_address;
984 /* We have to create a mask for the control register which says which bits
985 of the word pointed to by address to break on. */
986 if (arm_pc_is_thumb (gdbarch, address))
997 p->address = (unsigned int) address;
998 p->control = arm_hwbp_control_initialize (mask, arm_hwbp_break, 1);
1001 /* Get the ARM hardware breakpoint type from the RW value we're given when
1002 asked to set a watchpoint. */
1003 static arm_hwbp_type
1004 arm_linux_get_hwbp_type (int rw)
1007 return arm_hwbp_load;
1008 else if (rw == hw_write)
1009 return arm_hwbp_store;
1011 return arm_hwbp_access;
1014 /* Initialize the hardware breakpoint structure P for a watchpoint at ADDR
1015 to LEN. The type of watchpoint is given in RW. */
1017 arm_linux_hw_watchpoint_initialize (CORE_ADDR addr, int len, int rw,
1018 struct arm_linux_hw_breakpoint *p)
1020 const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
1023 gdb_assert (cap != NULL);
1024 gdb_assert (cap->max_wp_length != 0);
1026 mask = (1 << len) - 1;
1028 p->address = (unsigned int) addr;
1029 p->control = arm_hwbp_control_initialize (mask,
1030 arm_linux_get_hwbp_type (rw), 1);
1033 /* Are two break-/watch-points equal? */
1035 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint *p1,
1036 const struct arm_linux_hw_breakpoint *p2)
1038 return p1->address == p2->address && p1->control == p2->control;
1041 /* Callback to mark a watch-/breakpoint to be updated in all threads of
1042 the current process. */
1044 struct update_registers_data
1051 update_registers_callback (struct lwp_info *lwp, void *arg)
1053 struct update_registers_data *data = (struct update_registers_data *) arg;
1055 if (lwp->arch_private == NULL)
1056 lwp->arch_private = XCNEW (struct arch_lwp_info);
1058 /* The actual update is done later just before resuming the lwp,
1059 we just mark that the registers need updating. */
1061 lwp->arch_private->wpts_changed[data->index] = 1;
1063 lwp->arch_private->bpts_changed[data->index] = 1;
1065 /* If the lwp isn't stopped, force it to momentarily pause, so
1066 we can update its breakpoint registers. */
1068 linux_stop_lwp (lwp);
1073 /* Insert the hardware breakpoint (WATCHPOINT = 0) or watchpoint (WATCHPOINT
1074 =1) BPT for thread TID. */
1076 arm_linux_insert_hw_breakpoint1 (const struct arm_linux_hw_breakpoint* bpt,
1082 struct arm_linux_hw_breakpoint* bpts;
1083 struct update_registers_data data;
1085 pid = ptid_get_pid (inferior_ptid);
1086 pid_ptid = pid_to_ptid (pid);
1090 count = arm_linux_get_hw_watchpoint_count ();
1091 bpts = arm_linux_get_debug_reg_state (pid)->wpts;
1095 count = arm_linux_get_hw_breakpoint_count ();
1096 bpts = arm_linux_get_debug_reg_state (pid)->bpts;
1099 for (i = 0; i < count; ++i)
1100 if (!arm_hwbp_control_is_enabled (bpts[i].control))
1102 data.watch = watchpoint;
1105 iterate_over_lwps (pid_ptid, update_registers_callback, &data);
1109 gdb_assert (i != count);
1112 /* Remove the hardware breakpoint (WATCHPOINT = 0) or watchpoint
1113 (WATCHPOINT = 1) BPT for thread TID. */
1115 arm_linux_remove_hw_breakpoint1 (const struct arm_linux_hw_breakpoint *bpt,
1121 struct arm_linux_hw_breakpoint* bpts;
1122 struct update_registers_data data;
1124 pid = ptid_get_pid (inferior_ptid);
1125 pid_ptid = pid_to_ptid (pid);
1129 count = arm_linux_get_hw_watchpoint_count ();
1130 bpts = arm_linux_get_debug_reg_state (pid)->wpts;
1134 count = arm_linux_get_hw_breakpoint_count ();
1135 bpts = arm_linux_get_debug_reg_state (pid)->bpts;
1138 for (i = 0; i < count; ++i)
1139 if (arm_linux_hw_breakpoint_equal (bpt, bpts + i))
1141 data.watch = watchpoint;
1143 bpts[i].control = arm_hwbp_control_disable (bpts[i].control);
1144 iterate_over_lwps (pid_ptid, update_registers_callback, &data);
1148 gdb_assert (i != count);
1151 /* Insert a Hardware breakpoint. */
1153 arm_linux_insert_hw_breakpoint (struct target_ops *self,
1154 struct gdbarch *gdbarch,
1155 struct bp_target_info *bp_tgt)
1157 struct lwp_info *lp;
1158 struct arm_linux_hw_breakpoint p;
1160 if (arm_linux_get_hw_breakpoint_count () == 0)
1163 arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p);
1165 arm_linux_insert_hw_breakpoint1 (&p, 0);
1170 /* Remove a hardware breakpoint. */
1172 arm_linux_remove_hw_breakpoint (struct target_ops *self,
1173 struct gdbarch *gdbarch,
1174 struct bp_target_info *bp_tgt)
1176 struct lwp_info *lp;
1177 struct arm_linux_hw_breakpoint p;
1179 if (arm_linux_get_hw_breakpoint_count () == 0)
1182 arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p);
1184 arm_linux_remove_hw_breakpoint1 (&p, 0);
1189 /* Are we able to use a hardware watchpoint for the LEN bytes starting at
1192 arm_linux_region_ok_for_hw_watchpoint (struct target_ops *self,
1193 CORE_ADDR addr, int len)
1195 const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
1196 CORE_ADDR max_wp_length, aligned_addr;
1198 /* Can not set watchpoints for zero or negative lengths. */
1202 /* Need to be able to use the ptrace interface. */
1203 if (cap == NULL || cap->wp_count == 0)
1206 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
1207 range covered by a watchpoint. */
1208 max_wp_length = (CORE_ADDR)cap->max_wp_length;
1209 aligned_addr = addr & ~(max_wp_length - 1);
1211 if (aligned_addr + max_wp_length < addr + len)
1214 /* The current ptrace interface can only handle watchpoints that are a
1216 if ((len & (len - 1)) != 0)
1219 /* All tests passed so we must be able to set a watchpoint. */
1223 /* Insert a Hardware breakpoint. */
1225 arm_linux_insert_watchpoint (struct target_ops *self,
1226 CORE_ADDR addr, int len, int rw,
1227 struct expression *cond)
1229 struct lwp_info *lp;
1230 struct arm_linux_hw_breakpoint p;
1232 if (arm_linux_get_hw_watchpoint_count () == 0)
1235 arm_linux_hw_watchpoint_initialize (addr, len, rw, &p);
1237 arm_linux_insert_hw_breakpoint1 (&p, 1);
1242 /* Remove a hardware breakpoint. */
1244 arm_linux_remove_watchpoint (struct target_ops *self,
1245 CORE_ADDR addr, int len, int rw,
1246 struct expression *cond)
1248 struct lwp_info *lp;
1249 struct arm_linux_hw_breakpoint p;
1251 if (arm_linux_get_hw_watchpoint_count () == 0)
1254 arm_linux_hw_watchpoint_initialize (addr, len, rw, &p);
1256 arm_linux_remove_hw_breakpoint1 (&p, 1);
1261 /* What was the data address the target was stopped on accessing. */
1263 arm_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p)
1268 if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
1271 /* This must be a hardware breakpoint. */
1272 if (siginfo.si_signo != SIGTRAP
1273 || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
1276 /* We must be able to set hardware watchpoints. */
1277 if (arm_linux_get_hw_watchpoint_count () == 0)
1280 slot = siginfo.si_errno;
1282 /* If we are in a positive slot then we're looking at a breakpoint and not
1287 *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr;
1291 /* Has the target been stopped by hitting a watchpoint? */
1293 arm_linux_stopped_by_watchpoint (struct target_ops *ops)
1296 return arm_linux_stopped_data_address (ops, &addr);
1300 arm_linux_watchpoint_addr_within_range (struct target_ops *target,
1302 CORE_ADDR start, int length)
1304 return start <= addr && start + length - 1 >= addr;
1307 /* Handle thread creation. We need to copy the breakpoints and watchpoints
1308 in the parent thread to the child thread. */
1310 arm_linux_new_thread (struct lwp_info *lp)
1313 struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
1315 /* Mark that all the hardware breakpoint/watchpoint register pairs
1316 for this thread need to be initialized. */
1318 for (i = 0; i < MAX_BPTS; i++)
1320 info->bpts_changed[i] = 1;
1321 info->wpts_changed[i] = 1;
1324 lp->arch_private = info;
1327 /* Called when resuming a thread.
1328 The hardware debug registers are updated when there is any change. */
1331 arm_linux_prepare_to_resume (struct lwp_info *lwp)
1334 struct arm_linux_hw_breakpoint *bpts, *wpts;
1335 struct arch_lwp_info *arm_lwp_info = lwp->arch_private;
1337 pid = ptid_get_lwp (lwp->ptid);
1338 bpts = arm_linux_get_debug_reg_state (ptid_get_pid (lwp->ptid))->bpts;
1339 wpts = arm_linux_get_debug_reg_state (ptid_get_pid (lwp->ptid))->wpts;
1341 /* NULL means this is the main thread still going through the shell,
1342 or, no watchpoint has been set yet. In that case, there's
1344 if (arm_lwp_info == NULL)
1347 for (i = 0; i < arm_linux_get_hw_breakpoint_count (); i++)
1348 if (arm_lwp_info->bpts_changed[i])
1351 if (arm_hwbp_control_is_enabled (bpts[i].control))
1352 if (ptrace (PTRACE_SETHBPREGS, pid,
1353 (PTRACE_TYPE_ARG3) ((i << 1) + 1), &bpts[i].address) < 0)
1354 perror_with_name (_("Unexpected error setting breakpoint"));
1356 if (bpts[i].control != 0)
1357 if (ptrace (PTRACE_SETHBPREGS, pid,
1358 (PTRACE_TYPE_ARG3) ((i << 1) + 2), &bpts[i].control) < 0)
1359 perror_with_name (_("Unexpected error setting breakpoint"));
1361 arm_lwp_info->bpts_changed[i] = 0;
1364 for (i = 0; i < arm_linux_get_hw_watchpoint_count (); i++)
1365 if (arm_lwp_info->wpts_changed[i])
1368 if (arm_hwbp_control_is_enabled (wpts[i].control))
1369 if (ptrace (PTRACE_SETHBPREGS, pid,
1370 (PTRACE_TYPE_ARG3) -((i << 1) + 1), &wpts[i].address) < 0)
1371 perror_with_name (_("Unexpected error setting watchpoint"));
1373 if (wpts[i].control != 0)
1374 if (ptrace (PTRACE_SETHBPREGS, pid,
1375 (PTRACE_TYPE_ARG3) -((i << 1) + 2), &wpts[i].control) < 0)
1376 perror_with_name (_("Unexpected error setting watchpoint"));
1378 arm_lwp_info->wpts_changed[i] = 0;
1382 /* linux_nat_new_fork hook. */
1385 arm_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
1388 struct arm_linux_debug_reg_state *parent_state;
1389 struct arm_linux_debug_reg_state *child_state;
1391 /* NULL means no watchpoint has ever been set in the parent. In
1392 that case, there's nothing to do. */
1393 if (parent->arch_private == NULL)
1396 /* GDB core assumes the child inherits the watchpoints/hw
1397 breakpoints of the parent, and will remove them all from the
1398 forked off process. Copy the debug registers mirrors into the
1399 new process so that all breakpoints and watchpoints can be
1400 removed together. */
1402 parent_pid = ptid_get_pid (parent->ptid);
1403 parent_state = arm_linux_get_debug_reg_state (parent_pid);
1404 child_state = arm_linux_get_debug_reg_state (child_pid);
1405 *child_state = *parent_state;
1408 void _initialize_arm_linux_nat (void);
1411 _initialize_arm_linux_nat (void)
1413 struct target_ops *t;
1415 /* Fill in the generic GNU/Linux methods. */
1416 t = linux_target ();
1418 /* Add our register access methods. */
1419 t->to_fetch_registers = arm_linux_fetch_inferior_registers;
1420 t->to_store_registers = arm_linux_store_inferior_registers;
1422 /* Add our hardware breakpoint and watchpoint implementation. */
1423 t->to_can_use_hw_breakpoint = arm_linux_can_use_hw_breakpoint;
1424 t->to_insert_hw_breakpoint = arm_linux_insert_hw_breakpoint;
1425 t->to_remove_hw_breakpoint = arm_linux_remove_hw_breakpoint;
1426 t->to_region_ok_for_hw_watchpoint = arm_linux_region_ok_for_hw_watchpoint;
1427 t->to_insert_watchpoint = arm_linux_insert_watchpoint;
1428 t->to_remove_watchpoint = arm_linux_remove_watchpoint;
1429 t->to_stopped_by_watchpoint = arm_linux_stopped_by_watchpoint;
1430 t->to_stopped_data_address = arm_linux_stopped_data_address;
1431 t->to_watchpoint_addr_within_range = arm_linux_watchpoint_addr_within_range;
1433 t->to_read_description = arm_linux_read_description;
1435 /* Register the target. */
1436 linux_nat_add_target (t);
1438 /* Handle thread creation and exit. */
1439 linux_nat_set_new_thread (t, arm_linux_new_thread);
1440 linux_nat_set_prepare_to_resume (t, arm_linux_prepare_to_resume);
1442 /* Handle process creation and exit. */
1443 linux_nat_set_new_fork (t, arm_linux_new_fork);
1444 linux_nat_set_forget_process (t, arm_linux_forget_process);