1 /* GNU/Linux on ARM native support.
2 Copyright (C) 1999-2017 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"
32 #include "aarch32-linux-nat.h"
34 #include <elf/common.h>
36 #include "nat/gdb_ptrace.h"
37 #include <sys/utsname.h>
38 #include <sys/procfs.h>
40 #include "nat/linux-ptrace.h"
42 /* Prototypes for supply_gregset etc. */
45 /* Defines ps_err_e, struct ps_prochandle. */
46 #include "gdb_proc_service.h"
48 #ifndef PTRACE_GET_THREAD_AREA
49 #define PTRACE_GET_THREAD_AREA 22
52 #ifndef PTRACE_GETWMMXREGS
53 #define PTRACE_GETWMMXREGS 18
54 #define PTRACE_SETWMMXREGS 19
57 #ifndef PTRACE_GETVFPREGS
58 #define PTRACE_GETVFPREGS 27
59 #define PTRACE_SETVFPREGS 28
62 #ifndef PTRACE_GETHBPREGS
63 #define PTRACE_GETHBPREGS 29
64 #define PTRACE_SETHBPREGS 30
67 extern int arm_apcs_32
;
69 /* Get the whole floating point state of the process and store it
73 fetch_fpregs (struct regcache
*regcache
)
76 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
78 /* Get the thread id for the ptrace call. */
79 tid
= ptid_get_lwp (inferior_ptid
);
81 /* Read the floating point state. */
82 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
87 iov
.iov_len
= ARM_LINUX_SIZEOF_NWFPE
;
89 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iov
);
92 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
95 perror_with_name (_("Unable to fetch the floating point registers."));
98 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
99 fp
+ NWFPE_FPSR_OFFSET
);
101 /* Fetch the floating point registers. */
102 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
103 supply_nwfpe_register (regcache
, regno
, fp
);
106 /* Save the whole floating point state of the process using
107 the contents from regcache. */
110 store_fpregs (const struct regcache
*regcache
)
113 gdb_byte fp
[ARM_LINUX_SIZEOF_NWFPE
];
115 /* Get the thread id for the ptrace call. */
116 tid
= ptid_get_lwp (inferior_ptid
);
118 /* Read the floating point state. */
119 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
121 elf_fpregset_t fpregs
;
124 iov
.iov_base
= &fpregs
;
125 iov
.iov_len
= sizeof (fpregs
);
127 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iov
);
130 ret
= ptrace (PT_GETFPREGS
, tid
, 0, fp
);
133 perror_with_name (_("Unable to fetch the floating point registers."));
136 if (REG_VALID
== regcache_register_status (regcache
, ARM_FPS_REGNUM
))
137 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
, fp
+ NWFPE_FPSR_OFFSET
);
139 /* Store the floating point registers. */
140 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
141 if (REG_VALID
== regcache_register_status (regcache
, regno
))
142 collect_nwfpe_register (regcache
, regno
, fp
);
144 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
149 iov
.iov_len
= ARM_LINUX_SIZEOF_NWFPE
;
151 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_FPREGSET
, &iov
);
154 ret
= ptrace (PTRACE_SETFPREGS
, tid
, 0, fp
);
157 perror_with_name (_("Unable to store floating point registers."));
160 /* Fetch all general registers of the process and store into
164 fetch_regs (struct regcache
*regcache
)
169 /* Get the thread id for the ptrace call. */
170 tid
= ptid_get_lwp (inferior_ptid
);
172 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
176 iov
.iov_base
= ®s
;
177 iov
.iov_len
= sizeof (regs
);
179 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
);
182 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
185 perror_with_name (_("Unable to fetch general registers."));
187 aarch32_gp_regcache_supply (regcache
, (uint32_t *) regs
, arm_apcs_32
);
191 store_regs (const struct regcache
*regcache
)
196 /* Get the thread id for the ptrace call. */
197 tid
= ptid_get_lwp (inferior_ptid
);
199 /* Fetch the general registers. */
200 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
204 iov
.iov_base
= ®s
;
205 iov
.iov_len
= sizeof (regs
);
207 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
);
210 ret
= ptrace (PTRACE_GETREGS
, tid
, 0, ®s
);
213 perror_with_name (_("Unable to fetch general registers."));
215 aarch32_gp_regcache_collect (regcache
, (uint32_t *) regs
, arm_apcs_32
);
217 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
221 iov
.iov_base
= ®s
;
222 iov
.iov_len
= sizeof (regs
);
224 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_PRSTATUS
, &iov
);
227 ret
= ptrace (PTRACE_SETREGS
, tid
, 0, ®s
);
230 perror_with_name (_("Unable to store general registers."));
233 /* Fetch all WMMX registers of the process and store into
236 #define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
239 fetch_wmmx_regs (struct regcache
*regcache
)
241 char regbuf
[IWMMXT_REGS_SIZE
];
244 /* Get the thread id for the ptrace call. */
245 tid
= ptid_get_lwp (inferior_ptid
);
247 ret
= ptrace (PTRACE_GETWMMXREGS
, tid
, 0, regbuf
);
249 perror_with_name (_("Unable to fetch WMMX registers."));
251 for (regno
= 0; regno
< 16; regno
++)
252 regcache_raw_supply (regcache
, regno
+ ARM_WR0_REGNUM
,
255 for (regno
= 0; regno
< 2; regno
++)
256 regcache_raw_supply (regcache
, regno
+ ARM_WCSSF_REGNUM
,
257 ®buf
[16 * 8 + regno
* 4]);
259 for (regno
= 0; regno
< 4; regno
++)
260 regcache_raw_supply (regcache
, regno
+ ARM_WCGR0_REGNUM
,
261 ®buf
[16 * 8 + 2 * 4 + regno
* 4]);
265 store_wmmx_regs (const struct regcache
*regcache
)
267 char regbuf
[IWMMXT_REGS_SIZE
];
270 /* Get the thread id for the ptrace call. */
271 tid
= ptid_get_lwp (inferior_ptid
);
273 ret
= ptrace (PTRACE_GETWMMXREGS
, tid
, 0, regbuf
);
275 perror_with_name (_("Unable to fetch WMMX registers."));
277 for (regno
= 0; regno
< 16; regno
++)
278 if (REG_VALID
== regcache_register_status (regcache
,
279 regno
+ ARM_WR0_REGNUM
))
280 regcache_raw_collect (regcache
, regno
+ ARM_WR0_REGNUM
,
283 for (regno
= 0; regno
< 2; regno
++)
284 if (REG_VALID
== regcache_register_status (regcache
,
285 regno
+ ARM_WCSSF_REGNUM
))
286 regcache_raw_collect (regcache
, regno
+ ARM_WCSSF_REGNUM
,
287 ®buf
[16 * 8 + regno
* 4]);
289 for (regno
= 0; regno
< 4; regno
++)
290 if (REG_VALID
== regcache_register_status (regcache
,
291 regno
+ ARM_WCGR0_REGNUM
))
292 regcache_raw_collect (regcache
, regno
+ ARM_WCGR0_REGNUM
,
293 ®buf
[16 * 8 + 2 * 4 + regno
* 4]);
295 ret
= ptrace (PTRACE_SETWMMXREGS
, tid
, 0, regbuf
);
298 perror_with_name (_("Unable to store WMMX registers."));
302 fetch_vfp_regs (struct regcache
*regcache
)
304 gdb_byte regbuf
[VFP_REGS_SIZE
];
306 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
307 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
309 /* Get the thread id for the ptrace call. */
310 tid
= ptid_get_lwp (inferior_ptid
);
312 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
316 iov
.iov_base
= regbuf
;
317 iov
.iov_len
= VFP_REGS_SIZE
;
318 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iov
);
321 ret
= ptrace (PTRACE_GETVFPREGS
, tid
, 0, regbuf
);
324 perror_with_name (_("Unable to fetch VFP registers."));
326 aarch32_vfp_regcache_supply (regcache
, regbuf
,
327 tdep
->vfp_register_count
);
331 store_vfp_regs (const struct regcache
*regcache
)
333 gdb_byte regbuf
[VFP_REGS_SIZE
];
335 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
336 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
338 /* Get the thread id for the ptrace call. */
339 tid
= ptid_get_lwp (inferior_ptid
);
341 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
345 iov
.iov_base
= regbuf
;
346 iov
.iov_len
= VFP_REGS_SIZE
;
347 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iov
);
350 ret
= ptrace (PTRACE_GETVFPREGS
, tid
, 0, regbuf
);
353 perror_with_name (_("Unable to fetch VFP registers (for update)."));
355 aarch32_vfp_regcache_collect (regcache
, regbuf
,
356 tdep
->vfp_register_count
);
358 if (have_ptrace_getregset
== TRIBOOL_TRUE
)
362 iov
.iov_base
= regbuf
;
363 iov
.iov_len
= VFP_REGS_SIZE
;
364 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_ARM_VFP
, &iov
);
367 ret
= ptrace (PTRACE_SETVFPREGS
, tid
, 0, regbuf
);
370 perror_with_name (_("Unable to store VFP registers."));
373 /* Fetch registers from the child process. Fetch all registers if
374 regno == -1, otherwise fetch all general registers or all floating
375 point registers depending upon the value of regno. */
378 arm_linux_fetch_inferior_registers (struct target_ops
*ops
,
379 struct regcache
*regcache
, int regno
)
381 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
382 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
386 fetch_regs (regcache
);
387 if (tdep
->have_wmmx_registers
)
388 fetch_wmmx_regs (regcache
);
389 if (tdep
->vfp_register_count
> 0)
390 fetch_vfp_regs (regcache
);
391 if (tdep
->have_fpa_registers
)
392 fetch_fpregs (regcache
);
396 if (regno
< ARM_F0_REGNUM
|| regno
== ARM_PS_REGNUM
)
397 fetch_regs (regcache
);
398 else if (regno
>= ARM_F0_REGNUM
&& regno
<= ARM_FPS_REGNUM
)
399 fetch_fpregs (regcache
);
400 else if (tdep
->have_wmmx_registers
401 && regno
>= ARM_WR0_REGNUM
&& regno
<= ARM_WCGR7_REGNUM
)
402 fetch_wmmx_regs (regcache
);
403 else if (tdep
->vfp_register_count
> 0
404 && regno
>= ARM_D0_REGNUM
405 && regno
<= ARM_D0_REGNUM
+ tdep
->vfp_register_count
)
406 fetch_vfp_regs (regcache
);
410 /* Store registers back into the inferior. Store all registers if
411 regno == -1, otherwise store all general registers or all floating
412 point registers depending upon the value of regno. */
415 arm_linux_store_inferior_registers (struct target_ops
*ops
,
416 struct regcache
*regcache
, int regno
)
418 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
419 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
423 store_regs (regcache
);
424 if (tdep
->have_wmmx_registers
)
425 store_wmmx_regs (regcache
);
426 if (tdep
->vfp_register_count
> 0)
427 store_vfp_regs (regcache
);
428 if (tdep
->have_fpa_registers
)
429 store_fpregs (regcache
);
433 if (regno
< ARM_F0_REGNUM
|| regno
== ARM_PS_REGNUM
)
434 store_regs (regcache
);
435 else if ((regno
>= ARM_F0_REGNUM
) && (regno
<= ARM_FPS_REGNUM
))
436 store_fpregs (regcache
);
437 else if (tdep
->have_wmmx_registers
438 && regno
>= ARM_WR0_REGNUM
&& regno
<= ARM_WCGR7_REGNUM
)
439 store_wmmx_regs (regcache
);
440 else if (tdep
->vfp_register_count
> 0
441 && regno
>= ARM_D0_REGNUM
442 && regno
<= ARM_D0_REGNUM
+ tdep
->vfp_register_count
)
443 store_vfp_regs (regcache
);
447 /* Wrapper functions for the standard regset handling, used by
451 fill_gregset (const struct regcache
*regcache
,
452 gdb_gregset_t
*gregsetp
, int regno
)
454 arm_linux_collect_gregset (NULL
, regcache
, regno
, gregsetp
, 0);
458 supply_gregset (struct regcache
*regcache
, const gdb_gregset_t
*gregsetp
)
460 arm_linux_supply_gregset (NULL
, regcache
, -1, gregsetp
, 0);
464 fill_fpregset (const struct regcache
*regcache
,
465 gdb_fpregset_t
*fpregsetp
, int regno
)
467 arm_linux_collect_nwfpe (NULL
, regcache
, regno
, fpregsetp
, 0);
470 /* Fill GDB's register array with the floating-point register values
474 supply_fpregset (struct regcache
*regcache
, const gdb_fpregset_t
*fpregsetp
)
476 arm_linux_supply_nwfpe (NULL
, regcache
, -1, fpregsetp
, 0);
479 /* Fetch the thread-local storage pointer for libthread_db. */
482 ps_get_thread_area (struct ps_prochandle
*ph
,
483 lwpid_t lwpid
, int idx
, void **base
)
485 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
488 /* IDX is the bias from the thread pointer to the beginning of the
489 thread descriptor. It has to be subtracted due to implementation
490 quirks in libthread_db. */
491 *base
= (void *) ((char *)*base
- idx
);
496 static const struct target_desc
*
497 arm_linux_read_description (struct target_ops
*ops
)
499 CORE_ADDR arm_hwcap
= 0;
501 if (have_ptrace_getregset
== TRIBOOL_UNKNOWN
)
503 elf_gregset_t gpregs
;
505 int tid
= ptid_get_lwp (inferior_ptid
);
507 iov
.iov_base
= &gpregs
;
508 iov
.iov_len
= sizeof (gpregs
);
510 /* Check if PTRACE_GETREGSET works. */
511 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) < 0)
512 have_ptrace_getregset
= TRIBOOL_FALSE
;
514 have_ptrace_getregset
= TRIBOOL_TRUE
;
517 if (target_auxv_search (ops
, AT_HWCAP
, &arm_hwcap
) != 1)
519 return ops
->beneath
->to_read_description (ops
->beneath
);
522 if (arm_hwcap
& HWCAP_IWMMXT
)
523 return tdesc_arm_with_iwmmxt
;
525 if (arm_hwcap
& HWCAP_VFP
)
529 const struct target_desc
* result
= NULL
;
531 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
532 Neon with VFPv3-D32. */
533 if (arm_hwcap
& HWCAP_NEON
)
534 result
= tdesc_arm_with_neon
;
535 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
536 result
= tdesc_arm_with_vfpv3
;
538 result
= tdesc_arm_with_vfpv2
;
540 /* Now make sure that the kernel supports reading these
541 registers. Support was added in 2.6.30. */
542 pid
= ptid_get_lwp (inferior_ptid
);
544 buf
= (char *) alloca (VFP_REGS_SIZE
);
545 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0
552 return ops
->beneath
->to_read_description (ops
->beneath
);
555 /* Information describing the hardware breakpoint capabilities. */
556 struct arm_linux_hwbp_cap
559 gdb_byte max_wp_length
;
564 /* Since we cannot dynamically allocate subfields of arm_linux_process_info,
565 assume a maximum number of supported break-/watchpoints. */
569 /* Get hold of the Hardware Breakpoint information for the target we are
570 attached to. Returns NULL if the kernel doesn't support Hardware
571 breakpoints at all, or a pointer to the information structure. */
572 static const struct arm_linux_hwbp_cap
*
573 arm_linux_get_hwbp_cap (void)
575 /* The info structure we return. */
576 static struct arm_linux_hwbp_cap info
;
578 /* Is INFO in a good state? -1 means that no attempt has been made to
579 initialize INFO; 0 means an attempt has been made, but it failed; 1
580 means INFO is in an initialized state. */
581 static int available
= -1;
588 tid
= ptid_get_lwp (inferior_ptid
);
589 if (ptrace (PTRACE_GETHBPREGS
, tid
, 0, &val
) < 0)
593 info
.arch
= (gdb_byte
)((val
>> 24) & 0xff);
594 info
.max_wp_length
= (gdb_byte
)((val
>> 16) & 0xff);
595 info
.wp_count
= (gdb_byte
)((val
>> 8) & 0xff);
596 info
.bp_count
= (gdb_byte
)(val
& 0xff);
598 if (info
.wp_count
> MAX_WPTS
)
600 warning (_("arm-linux-gdb supports %d hardware watchpoints but target \
601 supports %d"), MAX_WPTS
, info
.wp_count
);
602 info
.wp_count
= MAX_WPTS
;
605 if (info
.bp_count
> MAX_BPTS
)
607 warning (_("arm-linux-gdb supports %d hardware breakpoints but target \
608 supports %d"), MAX_BPTS
, info
.bp_count
);
609 info
.bp_count
= MAX_BPTS
;
611 available
= (info
.arch
!= 0);
615 return available
== 1 ? &info
: NULL
;
618 /* How many hardware breakpoints are available? */
620 arm_linux_get_hw_breakpoint_count (void)
622 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
623 return cap
!= NULL
? cap
->bp_count
: 0;
626 /* How many hardware watchpoints are available? */
628 arm_linux_get_hw_watchpoint_count (void)
630 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
631 return cap
!= NULL
? cap
->wp_count
: 0;
634 /* Have we got a free break-/watch-point available for use? Returns -1 if
635 there is not an appropriate resource available, otherwise returns 1. */
637 arm_linux_can_use_hw_breakpoint (struct target_ops
*self
,
641 if (type
== bp_hardware_watchpoint
|| type
== bp_read_watchpoint
642 || type
== bp_access_watchpoint
|| type
== bp_watchpoint
)
644 int count
= arm_linux_get_hw_watchpoint_count ();
648 else if (cnt
+ ot
> count
)
651 else if (type
== bp_hardware_breakpoint
)
653 int count
= arm_linux_get_hw_breakpoint_count ();
657 else if (cnt
> count
)
666 /* Enum describing the different types of ARM hardware break-/watch-points. */
675 /* Type describing an ARM Hardware Breakpoint Control register value. */
676 typedef unsigned int arm_hwbp_control_t
;
678 /* Structure used to keep track of hardware break-/watch-points. */
679 struct arm_linux_hw_breakpoint
681 /* Address to break on, or being watched. */
682 unsigned int address
;
683 /* Control register for break-/watch- point. */
684 arm_hwbp_control_t control
;
687 /* Structure containing arrays of per process hardware break-/watchpoints
688 for caching address and control information.
690 The Linux ptrace interface to hardware break-/watch-points presents the
691 values in a vector centred around 0 (which is used fo generic information).
692 Positive indicies refer to breakpoint addresses/control registers, negative
693 indices to watchpoint addresses/control registers.
695 The Linux vector is indexed as follows:
696 -((i << 1) + 2): Control register for watchpoint i.
697 -((i << 1) + 1): Address register for watchpoint i.
698 0: Information register.
699 ((i << 1) + 1): Address register for breakpoint i.
700 ((i << 1) + 2): Control register for breakpoint i.
702 This structure is used as a per-thread cache of the state stored by the
703 kernel, so that we don't need to keep calling into the kernel to find a
706 We treat break-/watch-points with their enable bit clear as being deleted.
708 struct arm_linux_debug_reg_state
710 /* Hardware breakpoints for this process. */
711 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
712 /* Hardware watchpoints for this process. */
713 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
716 /* Per-process arch-specific data we want to keep. */
717 struct arm_linux_process_info
720 struct arm_linux_process_info
*next
;
721 /* The process identifier. */
723 /* Hardware break-/watchpoints state information. */
724 struct arm_linux_debug_reg_state state
;
728 /* Per-thread arch-specific data we want to keep. */
731 /* Non-zero if our copy differs from what's recorded in the thread. */
732 char bpts_changed
[MAX_BPTS
];
733 char wpts_changed
[MAX_WPTS
];
736 static struct arm_linux_process_info
*arm_linux_process_list
= NULL
;
738 /* Find process data for process PID. */
740 static struct arm_linux_process_info
*
741 arm_linux_find_process_pid (pid_t pid
)
743 struct arm_linux_process_info
*proc
;
745 for (proc
= arm_linux_process_list
; proc
; proc
= proc
->next
)
746 if (proc
->pid
== pid
)
752 /* Add process data for process PID. Returns newly allocated info
755 static struct arm_linux_process_info
*
756 arm_linux_add_process (pid_t pid
)
758 struct arm_linux_process_info
*proc
;
760 proc
= XCNEW (struct arm_linux_process_info
);
763 proc
->next
= arm_linux_process_list
;
764 arm_linux_process_list
= proc
;
769 /* Get data specific info for process PID, creating it if necessary.
770 Never returns NULL. */
772 static struct arm_linux_process_info
*
773 arm_linux_process_info_get (pid_t pid
)
775 struct arm_linux_process_info
*proc
;
777 proc
= arm_linux_find_process_pid (pid
);
779 proc
= arm_linux_add_process (pid
);
784 /* Called whenever GDB is no longer debugging process PID. It deletes
785 data structures that keep track of debug register state. */
788 arm_linux_forget_process (pid_t pid
)
790 struct arm_linux_process_info
*proc
, **proc_link
;
792 proc
= arm_linux_process_list
;
793 proc_link
= &arm_linux_process_list
;
797 if (proc
->pid
== pid
)
799 *proc_link
= proc
->next
;
805 proc_link
= &proc
->next
;
810 /* Get hardware break-/watchpoint state for process PID. */
812 static struct arm_linux_debug_reg_state
*
813 arm_linux_get_debug_reg_state (pid_t pid
)
815 return &arm_linux_process_info_get (pid
)->state
;
818 /* Initialize an ARM hardware break-/watch-point control register value.
819 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
820 type of break-/watch-point; ENABLE indicates whether the point is enabled.
822 static arm_hwbp_control_t
823 arm_hwbp_control_initialize (unsigned byte_address_select
,
824 arm_hwbp_type hwbp_type
,
827 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
828 gdb_assert (hwbp_type
!= arm_hwbp_break
829 || ((byte_address_select
& 0xfU
) != 0));
831 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
834 /* Does the breakpoint control value CONTROL have the enable bit set? */
836 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
838 return control
& 0x1;
841 /* Change a breakpoint control word so that it is in the disabled state. */
842 static arm_hwbp_control_t
843 arm_hwbp_control_disable (arm_hwbp_control_t control
)
845 return control
& ~0x1;
848 /* Initialise the hardware breakpoint structure P. The breakpoint will be
849 enabled, and will point to the placed address of BP_TGT. */
851 arm_linux_hw_breakpoint_initialize (struct gdbarch
*gdbarch
,
852 struct bp_target_info
*bp_tgt
,
853 struct arm_linux_hw_breakpoint
*p
)
856 CORE_ADDR address
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
858 /* We have to create a mask for the control register which says which bits
859 of the word pointed to by address to break on. */
860 if (arm_pc_is_thumb (gdbarch
, address
))
871 p
->address
= (unsigned int) address
;
872 p
->control
= arm_hwbp_control_initialize (mask
, arm_hwbp_break
, 1);
875 /* Get the ARM hardware breakpoint type from the TYPE value we're
876 given when asked to set a watchpoint. */
878 arm_linux_get_hwbp_type (enum target_hw_bp_type type
)
881 return arm_hwbp_load
;
882 else if (type
== hw_write
)
883 return arm_hwbp_store
;
885 return arm_hwbp_access
;
888 /* Initialize the hardware breakpoint structure P for a watchpoint at ADDR
889 to LEN. The type of watchpoint is given in RW. */
891 arm_linux_hw_watchpoint_initialize (CORE_ADDR addr
, int len
,
892 enum target_hw_bp_type type
,
893 struct arm_linux_hw_breakpoint
*p
)
895 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
898 gdb_assert (cap
!= NULL
);
899 gdb_assert (cap
->max_wp_length
!= 0);
901 mask
= (1 << len
) - 1;
903 p
->address
= (unsigned int) addr
;
904 p
->control
= arm_hwbp_control_initialize (mask
,
905 arm_linux_get_hwbp_type (type
), 1);
908 /* Are two break-/watch-points equal? */
910 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
911 const struct arm_linux_hw_breakpoint
*p2
)
913 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
916 /* Callback to mark a watch-/breakpoint to be updated in all threads of
917 the current process. */
919 struct update_registers_data
926 update_registers_callback (struct lwp_info
*lwp
, void *arg
)
928 struct update_registers_data
*data
= (struct update_registers_data
*) arg
;
930 if (lwp
->arch_private
== NULL
)
931 lwp
->arch_private
= XCNEW (struct arch_lwp_info
);
933 /* The actual update is done later just before resuming the lwp,
934 we just mark that the registers need updating. */
936 lwp
->arch_private
->wpts_changed
[data
->index
] = 1;
938 lwp
->arch_private
->bpts_changed
[data
->index
] = 1;
940 /* If the lwp isn't stopped, force it to momentarily pause, so
941 we can update its breakpoint registers. */
943 linux_stop_lwp (lwp
);
948 /* Insert the hardware breakpoint (WATCHPOINT = 0) or watchpoint (WATCHPOINT
949 =1) BPT for thread TID. */
951 arm_linux_insert_hw_breakpoint1 (const struct arm_linux_hw_breakpoint
* bpt
,
957 struct arm_linux_hw_breakpoint
* bpts
;
958 struct update_registers_data data
;
960 pid
= ptid_get_pid (inferior_ptid
);
961 pid_ptid
= pid_to_ptid (pid
);
965 count
= arm_linux_get_hw_watchpoint_count ();
966 bpts
= arm_linux_get_debug_reg_state (pid
)->wpts
;
970 count
= arm_linux_get_hw_breakpoint_count ();
971 bpts
= arm_linux_get_debug_reg_state (pid
)->bpts
;
974 for (i
= 0; i
< count
; ++i
)
975 if (!arm_hwbp_control_is_enabled (bpts
[i
].control
))
977 data
.watch
= watchpoint
;
980 iterate_over_lwps (pid_ptid
, update_registers_callback
, &data
);
984 gdb_assert (i
!= count
);
987 /* Remove the hardware breakpoint (WATCHPOINT = 0) or watchpoint
988 (WATCHPOINT = 1) BPT for thread TID. */
990 arm_linux_remove_hw_breakpoint1 (const struct arm_linux_hw_breakpoint
*bpt
,
996 struct arm_linux_hw_breakpoint
* bpts
;
997 struct update_registers_data data
;
999 pid
= ptid_get_pid (inferior_ptid
);
1000 pid_ptid
= pid_to_ptid (pid
);
1004 count
= arm_linux_get_hw_watchpoint_count ();
1005 bpts
= arm_linux_get_debug_reg_state (pid
)->wpts
;
1009 count
= arm_linux_get_hw_breakpoint_count ();
1010 bpts
= arm_linux_get_debug_reg_state (pid
)->bpts
;
1013 for (i
= 0; i
< count
; ++i
)
1014 if (arm_linux_hw_breakpoint_equal (bpt
, bpts
+ i
))
1016 data
.watch
= watchpoint
;
1018 bpts
[i
].control
= arm_hwbp_control_disable (bpts
[i
].control
);
1019 iterate_over_lwps (pid_ptid
, update_registers_callback
, &data
);
1023 gdb_assert (i
!= count
);
1026 /* Insert a Hardware breakpoint. */
1028 arm_linux_insert_hw_breakpoint (struct target_ops
*self
,
1029 struct gdbarch
*gdbarch
,
1030 struct bp_target_info
*bp_tgt
)
1032 struct lwp_info
*lp
;
1033 struct arm_linux_hw_breakpoint p
;
1035 if (arm_linux_get_hw_breakpoint_count () == 0)
1038 arm_linux_hw_breakpoint_initialize (gdbarch
, bp_tgt
, &p
);
1040 arm_linux_insert_hw_breakpoint1 (&p
, 0);
1045 /* Remove a hardware breakpoint. */
1047 arm_linux_remove_hw_breakpoint (struct target_ops
*self
,
1048 struct gdbarch
*gdbarch
,
1049 struct bp_target_info
*bp_tgt
)
1051 struct lwp_info
*lp
;
1052 struct arm_linux_hw_breakpoint p
;
1054 if (arm_linux_get_hw_breakpoint_count () == 0)
1057 arm_linux_hw_breakpoint_initialize (gdbarch
, bp_tgt
, &p
);
1059 arm_linux_remove_hw_breakpoint1 (&p
, 0);
1064 /* Are we able to use a hardware watchpoint for the LEN bytes starting at
1067 arm_linux_region_ok_for_hw_watchpoint (struct target_ops
*self
,
1068 CORE_ADDR addr
, int len
)
1070 const struct arm_linux_hwbp_cap
*cap
= arm_linux_get_hwbp_cap ();
1071 CORE_ADDR max_wp_length
, aligned_addr
;
1073 /* Can not set watchpoints for zero or negative lengths. */
1077 /* Need to be able to use the ptrace interface. */
1078 if (cap
== NULL
|| cap
->wp_count
== 0)
1081 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
1082 range covered by a watchpoint. */
1083 max_wp_length
= (CORE_ADDR
)cap
->max_wp_length
;
1084 aligned_addr
= addr
& ~(max_wp_length
- 1);
1086 if (aligned_addr
+ max_wp_length
< addr
+ len
)
1089 /* The current ptrace interface can only handle watchpoints that are a
1091 if ((len
& (len
- 1)) != 0)
1094 /* All tests passed so we must be able to set a watchpoint. */
1098 /* Insert a Hardware breakpoint. */
1100 arm_linux_insert_watchpoint (struct target_ops
*self
,
1101 CORE_ADDR addr
, int len
,
1102 enum target_hw_bp_type rw
,
1103 struct expression
*cond
)
1105 struct lwp_info
*lp
;
1106 struct arm_linux_hw_breakpoint p
;
1108 if (arm_linux_get_hw_watchpoint_count () == 0)
1111 arm_linux_hw_watchpoint_initialize (addr
, len
, rw
, &p
);
1113 arm_linux_insert_hw_breakpoint1 (&p
, 1);
1118 /* Remove a hardware breakpoint. */
1120 arm_linux_remove_watchpoint (struct target_ops
*self
, CORE_ADDR addr
,
1121 int len
, enum target_hw_bp_type rw
,
1122 struct expression
*cond
)
1124 struct lwp_info
*lp
;
1125 struct arm_linux_hw_breakpoint p
;
1127 if (arm_linux_get_hw_watchpoint_count () == 0)
1130 arm_linux_hw_watchpoint_initialize (addr
, len
, rw
, &p
);
1132 arm_linux_remove_hw_breakpoint1 (&p
, 1);
1137 /* What was the data address the target was stopped on accessing. */
1139 arm_linux_stopped_data_address (struct target_ops
*target
, CORE_ADDR
*addr_p
)
1144 if (!linux_nat_get_siginfo (inferior_ptid
, &siginfo
))
1147 /* This must be a hardware breakpoint. */
1148 if (siginfo
.si_signo
!= SIGTRAP
1149 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
1152 /* We must be able to set hardware watchpoints. */
1153 if (arm_linux_get_hw_watchpoint_count () == 0)
1156 slot
= siginfo
.si_errno
;
1158 /* If we are in a positive slot then we're looking at a breakpoint and not
1163 *addr_p
= (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
1167 /* Has the target been stopped by hitting a watchpoint? */
1169 arm_linux_stopped_by_watchpoint (struct target_ops
*ops
)
1172 return arm_linux_stopped_data_address (ops
, &addr
);
1176 arm_linux_watchpoint_addr_within_range (struct target_ops
*target
,
1178 CORE_ADDR start
, int length
)
1180 return start
<= addr
&& start
+ length
- 1 >= addr
;
1183 /* Handle thread creation. We need to copy the breakpoints and watchpoints
1184 in the parent thread to the child thread. */
1186 arm_linux_new_thread (struct lwp_info
*lp
)
1189 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
1191 /* Mark that all the hardware breakpoint/watchpoint register pairs
1192 for this thread need to be initialized. */
1194 for (i
= 0; i
< MAX_BPTS
; i
++)
1196 info
->bpts_changed
[i
] = 1;
1197 info
->wpts_changed
[i
] = 1;
1200 lp
->arch_private
= info
;
1203 /* Called when resuming a thread.
1204 The hardware debug registers are updated when there is any change. */
1207 arm_linux_prepare_to_resume (struct lwp_info
*lwp
)
1210 struct arm_linux_hw_breakpoint
*bpts
, *wpts
;
1211 struct arch_lwp_info
*arm_lwp_info
= lwp
->arch_private
;
1213 pid
= ptid_get_lwp (lwp
->ptid
);
1214 bpts
= arm_linux_get_debug_reg_state (ptid_get_pid (lwp
->ptid
))->bpts
;
1215 wpts
= arm_linux_get_debug_reg_state (ptid_get_pid (lwp
->ptid
))->wpts
;
1217 /* NULL means this is the main thread still going through the shell,
1218 or, no watchpoint has been set yet. In that case, there's
1220 if (arm_lwp_info
== NULL
)
1223 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
1224 if (arm_lwp_info
->bpts_changed
[i
])
1227 if (arm_hwbp_control_is_enabled (bpts
[i
].control
))
1228 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1229 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1), &bpts
[i
].address
) < 0)
1230 perror_with_name (_("Unexpected error setting breakpoint"));
1232 if (bpts
[i
].control
!= 0)
1233 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1234 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2), &bpts
[i
].control
) < 0)
1235 perror_with_name (_("Unexpected error setting breakpoint"));
1237 arm_lwp_info
->bpts_changed
[i
] = 0;
1240 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
1241 if (arm_lwp_info
->wpts_changed
[i
])
1244 if (arm_hwbp_control_is_enabled (wpts
[i
].control
))
1245 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1246 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1), &wpts
[i
].address
) < 0)
1247 perror_with_name (_("Unexpected error setting watchpoint"));
1249 if (wpts
[i
].control
!= 0)
1250 if (ptrace (PTRACE_SETHBPREGS
, pid
,
1251 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2), &wpts
[i
].control
) < 0)
1252 perror_with_name (_("Unexpected error setting watchpoint"));
1254 arm_lwp_info
->wpts_changed
[i
] = 0;
1258 /* linux_nat_new_fork hook. */
1261 arm_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
1264 struct arm_linux_debug_reg_state
*parent_state
;
1265 struct arm_linux_debug_reg_state
*child_state
;
1267 /* NULL means no watchpoint has ever been set in the parent. In
1268 that case, there's nothing to do. */
1269 if (parent
->arch_private
== NULL
)
1272 /* GDB core assumes the child inherits the watchpoints/hw
1273 breakpoints of the parent, and will remove them all from the
1274 forked off process. Copy the debug registers mirrors into the
1275 new process so that all breakpoints and watchpoints can be
1276 removed together. */
1278 parent_pid
= ptid_get_pid (parent
->ptid
);
1279 parent_state
= arm_linux_get_debug_reg_state (parent_pid
);
1280 child_state
= arm_linux_get_debug_reg_state (child_pid
);
1281 *child_state
= *parent_state
;
1284 void _initialize_arm_linux_nat (void);
1287 _initialize_arm_linux_nat (void)
1289 struct target_ops
*t
;
1291 /* Fill in the generic GNU/Linux methods. */
1292 t
= linux_target ();
1294 /* Add our register access methods. */
1295 t
->to_fetch_registers
= arm_linux_fetch_inferior_registers
;
1296 t
->to_store_registers
= arm_linux_store_inferior_registers
;
1298 /* Add our hardware breakpoint and watchpoint implementation. */
1299 t
->to_can_use_hw_breakpoint
= arm_linux_can_use_hw_breakpoint
;
1300 t
->to_insert_hw_breakpoint
= arm_linux_insert_hw_breakpoint
;
1301 t
->to_remove_hw_breakpoint
= arm_linux_remove_hw_breakpoint
;
1302 t
->to_region_ok_for_hw_watchpoint
= arm_linux_region_ok_for_hw_watchpoint
;
1303 t
->to_insert_watchpoint
= arm_linux_insert_watchpoint
;
1304 t
->to_remove_watchpoint
= arm_linux_remove_watchpoint
;
1305 t
->to_stopped_by_watchpoint
= arm_linux_stopped_by_watchpoint
;
1306 t
->to_stopped_data_address
= arm_linux_stopped_data_address
;
1307 t
->to_watchpoint_addr_within_range
= arm_linux_watchpoint_addr_within_range
;
1309 t
->to_read_description
= arm_linux_read_description
;
1311 /* Register the target. */
1312 linux_nat_add_target (t
);
1314 /* Handle thread creation and exit. */
1315 linux_nat_set_new_thread (t
, arm_linux_new_thread
);
1316 linux_nat_set_prepare_to_resume (t
, arm_linux_prepare_to_resume
);
1318 /* Handle process creation and exit. */
1319 linux_nat_set_new_fork (t
, arm_linux_new_fork
);
1320 linux_nat_set_forget_process (t
, arm_linux_forget_process
);