1 /* Native-dependent code for GNU/Linux AArch64.
3 Copyright (C) 2011-2018 Free Software Foundation, Inc.
4 Contributed by ARM Ltd.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "linux-nat.h"
27 #include "target-descriptions.h"
30 #include "aarch64-tdep.h"
31 #include "aarch64-linux-tdep.h"
32 #include "aarch32-linux-nat.h"
33 #include "nat/aarch64-linux.h"
34 #include "nat/aarch64-linux-hw-point.h"
35 #include "nat/aarch64-sve-linux-ptrace.h"
37 #include "elf/external.h"
38 #include "elf/common.h"
40 #include "nat/gdb_ptrace.h"
41 #include <sys/utsname.h>
42 #include <asm/ptrace.h>
46 /* Defines ps_err_e, struct ps_prochandle. */
47 #include "gdb_proc_service.h"
50 #define TRAP_HWBKPT 0x0004
53 class aarch64_linux_nat_target final
: public linux_nat_target
56 /* Add our register access methods. */
57 void fetch_registers (struct regcache
*, int) override
;
58 void store_registers (struct regcache
*, int) override
;
60 const struct target_desc
*read_description () override
;
62 /* Add our hardware breakpoint and watchpoint implementation. */
63 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
64 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
65 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
66 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
67 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
68 struct expression
*) override
;
69 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
70 struct expression
*) override
;
71 bool stopped_by_watchpoint () override
;
72 bool stopped_data_address (CORE_ADDR
*) override
;
73 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
75 int can_do_single_step () override
;
77 /* Override the GNU/Linux inferior startup hook. */
78 void post_startup_inferior (ptid_t
) override
;
80 /* These three defer to common nat/ code. */
81 void low_new_thread (struct lwp_info
*lp
) override
82 { aarch64_linux_new_thread (lp
); }
83 void low_delete_thread (struct arch_lwp_info
*lp
) override
84 { aarch64_linux_delete_thread (lp
); }
85 void low_prepare_to_resume (struct lwp_info
*lp
) override
86 { aarch64_linux_prepare_to_resume (lp
); }
88 void low_new_fork (struct lwp_info
*parent
, pid_t child_pid
) override
;
89 void low_forget_process (pid_t pid
) override
;
91 /* Add our siginfo layout converter. */
92 bool low_siginfo_fixup (siginfo_t
*ptrace
, gdb_byte
*inf
, int direction
)
96 static aarch64_linux_nat_target the_aarch64_linux_nat_target
;
98 /* Per-process data. We don't bind this to a per-inferior registry
99 because of targets like x86 GNU/Linux that need to keep track of
100 processes that aren't bound to any inferior (e.g., fork children,
103 struct aarch64_process_info
106 struct aarch64_process_info
*next
;
108 /* The process identifier. */
111 /* Copy of aarch64 hardware debug registers. */
112 struct aarch64_debug_reg_state state
;
115 static struct aarch64_process_info
*aarch64_process_list
= NULL
;
117 /* Find process data for process PID. */
119 static struct aarch64_process_info
*
120 aarch64_find_process_pid (pid_t pid
)
122 struct aarch64_process_info
*proc
;
124 for (proc
= aarch64_process_list
; proc
; proc
= proc
->next
)
125 if (proc
->pid
== pid
)
131 /* Add process data for process PID. Returns newly allocated info
134 static struct aarch64_process_info
*
135 aarch64_add_process (pid_t pid
)
137 struct aarch64_process_info
*proc
;
139 proc
= XCNEW (struct aarch64_process_info
);
142 proc
->next
= aarch64_process_list
;
143 aarch64_process_list
= proc
;
148 /* Get data specific info for process PID, creating it if necessary.
149 Never returns NULL. */
151 static struct aarch64_process_info
*
152 aarch64_process_info_get (pid_t pid
)
154 struct aarch64_process_info
*proc
;
156 proc
= aarch64_find_process_pid (pid
);
158 proc
= aarch64_add_process (pid
);
163 /* Called whenever GDB is no longer debugging process PID. It deletes
164 data structures that keep track of debug register state. */
167 aarch64_linux_nat_target::low_forget_process (pid_t pid
)
169 struct aarch64_process_info
*proc
, **proc_link
;
171 proc
= aarch64_process_list
;
172 proc_link
= &aarch64_process_list
;
176 if (proc
->pid
== pid
)
178 *proc_link
= proc
->next
;
184 proc_link
= &proc
->next
;
189 /* Get debug registers state for process PID. */
191 struct aarch64_debug_reg_state
*
192 aarch64_get_debug_reg_state (pid_t pid
)
194 return &aarch64_process_info_get (pid
)->state
;
197 /* Fill GDB's register array with the general-purpose register values
198 from the current thread. */
201 fetch_gregs_from_thread (struct regcache
*regcache
)
204 struct gdbarch
*gdbarch
= regcache
->arch ();
208 /* Make sure REGS can hold all registers contents on both aarch64
210 gdb_static_assert (sizeof (regs
) >= 18 * 4);
212 tid
= ptid_get_lwp (regcache
->ptid ());
214 iovec
.iov_base
= ®s
;
215 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
216 iovec
.iov_len
= 18 * 4;
218 iovec
.iov_len
= sizeof (regs
);
220 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
222 perror_with_name (_("Unable to fetch general registers."));
224 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
225 aarch32_gp_regcache_supply (regcache
, (uint32_t *) regs
, 1);
230 for (regno
= AARCH64_X0_REGNUM
; regno
<= AARCH64_CPSR_REGNUM
; regno
++)
231 regcache
->raw_supply (regno
, ®s
[regno
- AARCH64_X0_REGNUM
]);
235 /* Store to the current thread the valid general-purpose register
236 values in the GDB's register array. */
239 store_gregs_to_thread (const struct regcache
*regcache
)
244 struct gdbarch
*gdbarch
= regcache
->arch ();
246 /* Make sure REGS can hold all registers contents on both aarch64
248 gdb_static_assert (sizeof (regs
) >= 18 * 4);
249 tid
= ptid_get_lwp (regcache
->ptid ());
251 iovec
.iov_base
= ®s
;
252 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
253 iovec
.iov_len
= 18 * 4;
255 iovec
.iov_len
= sizeof (regs
);
257 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
259 perror_with_name (_("Unable to fetch general registers."));
261 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
262 aarch32_gp_regcache_collect (regcache
, (uint32_t *) regs
, 1);
267 for (regno
= AARCH64_X0_REGNUM
; regno
<= AARCH64_CPSR_REGNUM
; regno
++)
268 if (REG_VALID
== regcache
->get_register_status (regno
))
269 regcache
->raw_collect (regno
, ®s
[regno
- AARCH64_X0_REGNUM
]);
272 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
274 perror_with_name (_("Unable to store general registers."));
277 /* Fill GDB's register array with the fp/simd register values
278 from the current thread. */
281 fetch_fpregs_from_thread (struct regcache
*regcache
)
286 struct gdbarch
*gdbarch
= regcache
->arch ();
288 /* Make sure REGS can hold all VFP registers contents on both aarch64
290 gdb_static_assert (sizeof regs
>= VFP_REGS_SIZE
);
292 tid
= ptid_get_lwp (regcache
->ptid ());
294 iovec
.iov_base
= ®s
;
296 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
298 iovec
.iov_len
= VFP_REGS_SIZE
;
300 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
302 perror_with_name (_("Unable to fetch VFP registers."));
304 aarch32_vfp_regcache_supply (regcache
, (gdb_byte
*) ®s
, 32);
310 iovec
.iov_len
= sizeof (regs
);
312 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iovec
);
314 perror_with_name (_("Unable to fetch vFP/SIMD registers."));
316 for (regno
= AARCH64_V0_REGNUM
; regno
<= AARCH64_V31_REGNUM
; regno
++)
317 regcache
->raw_supply (regno
, ®s
.vregs
[regno
- AARCH64_V0_REGNUM
]);
319 regcache
->raw_supply (AARCH64_FPSR_REGNUM
, ®s
.fpsr
);
320 regcache
->raw_supply (AARCH64_FPCR_REGNUM
, ®s
.fpcr
);
324 /* Store to the current thread the valid fp/simd register
325 values in the GDB's register array. */
328 store_fpregs_to_thread (const struct regcache
*regcache
)
333 struct gdbarch
*gdbarch
= regcache
->arch ();
335 /* Make sure REGS can hold all VFP registers contents on both aarch64
337 gdb_static_assert (sizeof regs
>= VFP_REGS_SIZE
);
338 tid
= ptid_get_lwp (regcache
->ptid ());
340 iovec
.iov_base
= ®s
;
342 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
344 iovec
.iov_len
= VFP_REGS_SIZE
;
346 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
348 perror_with_name (_("Unable to fetch VFP registers."));
350 aarch32_vfp_regcache_collect (regcache
, (gdb_byte
*) ®s
, 32);
356 iovec
.iov_len
= sizeof (regs
);
358 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iovec
);
360 perror_with_name (_("Unable to fetch FP/SIMD registers."));
362 for (regno
= AARCH64_V0_REGNUM
; regno
<= AARCH64_V31_REGNUM
; regno
++)
363 if (REG_VALID
== regcache
->get_register_status (regno
))
364 regcache
->raw_collect
365 (regno
, (char *) ®s
.vregs
[regno
- AARCH64_V0_REGNUM
]);
367 if (REG_VALID
== regcache
->get_register_status (AARCH64_FPSR_REGNUM
))
368 regcache
->raw_collect (AARCH64_FPSR_REGNUM
, (char *) ®s
.fpsr
);
369 if (REG_VALID
== regcache
->get_register_status (AARCH64_FPCR_REGNUM
))
370 regcache
->raw_collect (AARCH64_FPCR_REGNUM
, (char *) ®s
.fpcr
);
373 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
375 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
377 perror_with_name (_("Unable to store VFP registers."));
381 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_FPREGSET
, &iovec
);
383 perror_with_name (_("Unable to store FP/SIMD registers."));
387 /* Fill GDB's register array with the sve register values
388 from the current thread. */
391 fetch_sveregs_from_thread (struct regcache
*regcache
)
393 std::unique_ptr
<gdb_byte
[]> base
394 = aarch64_sve_get_sveregs (ptid_get_lwp (regcache
->ptid ()));
395 aarch64_sve_regs_copy_to_reg_buf (regcache
, base
.get ());
398 /* Store to the current thread the valid sve register
399 values in the GDB's register array. */
402 store_sveregs_to_thread (struct regcache
*regcache
)
406 int tid
= ptid_get_lwp (regcache
->ptid ());
408 /* Obtain a dump of SVE registers from ptrace. */
409 std::unique_ptr
<gdb_byte
[]> base
= aarch64_sve_get_sveregs (tid
);
411 /* Overwrite with regcache state. */
412 aarch64_sve_regs_copy_from_reg_buf (regcache
, base
.get ());
414 /* Write back to the kernel. */
415 iovec
.iov_base
= base
.get ();
416 iovec
.iov_len
= ((struct user_sve_header
*) base
.get ())->size
;
417 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_ARM_SVE
, &iovec
);
420 perror_with_name (_("Unable to store sve registers"));
423 /* Implement the "fetch_registers" target_ops method. */
426 aarch64_linux_nat_target::fetch_registers (struct regcache
*regcache
,
429 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
433 fetch_gregs_from_thread (regcache
);
434 if (tdep
->has_sve ())
435 fetch_sveregs_from_thread (regcache
);
437 fetch_fpregs_from_thread (regcache
);
439 else if (regno
< AARCH64_V0_REGNUM
)
440 fetch_gregs_from_thread (regcache
);
441 else if (tdep
->has_sve ())
442 fetch_sveregs_from_thread (regcache
);
444 fetch_fpregs_from_thread (regcache
);
447 /* Implement the "store_registers" target_ops method. */
450 aarch64_linux_nat_target::store_registers (struct regcache
*regcache
,
453 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
457 store_gregs_to_thread (regcache
);
458 if (tdep
->has_sve ())
459 store_sveregs_to_thread (regcache
);
461 store_fpregs_to_thread (regcache
);
463 else if (regno
< AARCH64_V0_REGNUM
)
464 store_gregs_to_thread (regcache
);
465 else if (tdep
->has_sve ())
466 store_sveregs_to_thread (regcache
);
468 store_fpregs_to_thread (regcache
);
471 /* Fill register REGNO (if it is a general-purpose register) in
472 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
473 do this for all registers. */
476 fill_gregset (const struct regcache
*regcache
,
477 gdb_gregset_t
*gregsetp
, int regno
)
479 regcache_collect_regset (&aarch64_linux_gregset
, regcache
,
480 regno
, (gdb_byte
*) gregsetp
,
481 AARCH64_LINUX_SIZEOF_GREGSET
);
484 /* Fill GDB's register array with the general-purpose register values
488 supply_gregset (struct regcache
*regcache
, const gdb_gregset_t
*gregsetp
)
490 regcache_supply_regset (&aarch64_linux_gregset
, regcache
, -1,
491 (const gdb_byte
*) gregsetp
,
492 AARCH64_LINUX_SIZEOF_GREGSET
);
495 /* Fill register REGNO (if it is a floating-point register) in
496 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
497 do this for all registers. */
500 fill_fpregset (const struct regcache
*regcache
,
501 gdb_fpregset_t
*fpregsetp
, int regno
)
503 regcache_collect_regset (&aarch64_linux_fpregset
, regcache
,
504 regno
, (gdb_byte
*) fpregsetp
,
505 AARCH64_LINUX_SIZEOF_FPREGSET
);
508 /* Fill GDB's register array with the floating-point register values
512 supply_fpregset (struct regcache
*regcache
, const gdb_fpregset_t
*fpregsetp
)
514 regcache_supply_regset (&aarch64_linux_fpregset
, regcache
, -1,
515 (const gdb_byte
*) fpregsetp
,
516 AARCH64_LINUX_SIZEOF_FPREGSET
);
519 /* linux_nat_new_fork hook. */
522 aarch64_linux_nat_target::low_new_fork (struct lwp_info
*parent
,
526 struct aarch64_debug_reg_state
*parent_state
;
527 struct aarch64_debug_reg_state
*child_state
;
529 /* NULL means no watchpoint has ever been set in the parent. In
530 that case, there's nothing to do. */
531 if (parent
->arch_private
== NULL
)
534 /* GDB core assumes the child inherits the watchpoints/hw
535 breakpoints of the parent, and will remove them all from the
536 forked off process. Copy the debug registers mirrors into the
537 new process so that all breakpoints and watchpoints can be
540 parent_pid
= ptid_get_pid (parent
->ptid
);
541 parent_state
= aarch64_get_debug_reg_state (parent_pid
);
542 child_state
= aarch64_get_debug_reg_state (child_pid
);
543 *child_state
= *parent_state
;
547 /* Called by libthread_db. Returns a pointer to the thread local
548 storage (or its descriptor). */
551 ps_get_thread_area (struct ps_prochandle
*ph
,
552 lwpid_t lwpid
, int idx
, void **base
)
555 = (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word
== 64);
557 return aarch64_ps_get_thread_area (ph
, lwpid
, idx
, base
, is_64bit_p
);
561 /* Implement the "post_startup_inferior" target_ops method. */
564 aarch64_linux_nat_target::post_startup_inferior (ptid_t ptid
)
566 low_forget_process (ptid_get_pid (ptid
));
567 aarch64_linux_get_debug_reg_capacity (ptid_get_pid (ptid
));
568 linux_nat_target::post_startup_inferior (ptid
);
571 extern struct target_desc
*tdesc_arm_with_neon
;
573 /* Implement the "read_description" target_ops method. */
575 const struct target_desc
*
576 aarch64_linux_nat_target::read_description ()
579 gdb_byte regbuf
[VFP_REGS_SIZE
];
582 tid
= ptid_get_lwp (inferior_ptid
);
584 iovec
.iov_base
= regbuf
;
585 iovec
.iov_len
= VFP_REGS_SIZE
;
587 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
589 return tdesc_arm_with_neon
;
591 return aarch64_read_description (aarch64_sve_get_vq (tid
));
594 /* Convert a native/host siginfo object, into/from the siginfo in the
595 layout of the inferiors' architecture. Returns true if any
596 conversion was done; false otherwise. If DIRECTION is 1, then copy
597 from INF to NATIVE. If DIRECTION is 0, copy from NATIVE to
601 aarch64_linux_nat_target::low_siginfo_fixup (siginfo_t
*native
, gdb_byte
*inf
,
604 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
606 /* Is the inferior 32-bit? If so, then do fixup the siginfo
608 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
611 aarch64_compat_siginfo_from_siginfo ((struct compat_siginfo
*) inf
,
614 aarch64_siginfo_from_compat_siginfo (native
,
615 (struct compat_siginfo
*) inf
);
623 /* Returns the number of hardware watchpoints of type TYPE that we can
624 set. Value is positive if we can set CNT watchpoints, zero if
625 setting watchpoints of type TYPE is not supported, and negative if
626 CNT is more than the maximum number of watchpoints of type TYPE
627 that we can support. TYPE is one of bp_hardware_watchpoint,
628 bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
629 CNT is the number of such watchpoints used so far (including this
630 one). OTHERTYPE is non-zero if other types of watchpoints are
631 currently enabled. */
634 aarch64_linux_nat_target::can_use_hw_breakpoint (enum bptype type
,
635 int cnt
, int othertype
)
637 if (type
== bp_hardware_watchpoint
|| type
== bp_read_watchpoint
638 || type
== bp_access_watchpoint
|| type
== bp_watchpoint
)
640 if (aarch64_num_wp_regs
== 0)
643 else if (type
== bp_hardware_breakpoint
)
645 if (aarch64_num_bp_regs
== 0)
649 gdb_assert_not_reached ("unexpected breakpoint type");
651 /* We always return 1 here because we don't have enough information
652 about possible overlap of addresses that they want to watch. As an
653 extreme example, consider the case where all the watchpoints watch
654 the same address and the same region length: then we can handle a
655 virtually unlimited number of watchpoints, due to debug register
656 sharing implemented via reference counts. */
660 /* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address.
661 Return 0 on success, -1 on failure. */
664 aarch64_linux_nat_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
665 struct bp_target_info
*bp_tgt
)
668 CORE_ADDR addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
670 const enum target_hw_bp_type type
= hw_execute
;
671 struct aarch64_debug_reg_state
*state
672 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
674 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
679 "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
680 (unsigned long) addr
, len
);
682 ret
= aarch64_handle_breakpoint (type
, addr
, len
, 1 /* is_insert */, state
);
686 aarch64_show_debug_reg_state (state
,
687 "insert_hw_breakpoint", addr
, len
, type
);
693 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
694 Return 0 on success, -1 on failure. */
697 aarch64_linux_nat_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
698 struct bp_target_info
*bp_tgt
)
701 CORE_ADDR addr
= bp_tgt
->placed_address
;
703 const enum target_hw_bp_type type
= hw_execute
;
704 struct aarch64_debug_reg_state
*state
705 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
707 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
711 (gdb_stdlog
, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
712 (unsigned long) addr
, len
);
714 ret
= aarch64_handle_breakpoint (type
, addr
, len
, 0 /* is_insert */, state
);
718 aarch64_show_debug_reg_state (state
,
719 "remove_hw_watchpoint", addr
, len
, type
);
725 /* Implement the "insert_watchpoint" target_ops method.
727 Insert a watchpoint to watch a memory region which starts at
728 address ADDR and whose length is LEN bytes. Watch memory accesses
729 of the type TYPE. Return 0 on success, -1 on failure. */
732 aarch64_linux_nat_target::insert_watchpoint (CORE_ADDR addr
, int len
,
733 enum target_hw_bp_type type
,
734 struct expression
*cond
)
737 struct aarch64_debug_reg_state
*state
738 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
741 fprintf_unfiltered (gdb_stdlog
,
742 "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
743 (unsigned long) addr
, len
);
745 gdb_assert (type
!= hw_execute
);
747 ret
= aarch64_handle_watchpoint (type
, addr
, len
, 1 /* is_insert */, state
);
751 aarch64_show_debug_reg_state (state
,
752 "insert_watchpoint", addr
, len
, type
);
758 /* Implement the "remove_watchpoint" target_ops method.
759 Remove a watchpoint that watched the memory region which starts at
760 address ADDR, whose length is LEN bytes, and for accesses of the
761 type TYPE. Return 0 on success, -1 on failure. */
764 aarch64_linux_nat_target::remove_watchpoint (CORE_ADDR addr
, int len
,
765 enum target_hw_bp_type type
,
766 struct expression
*cond
)
769 struct aarch64_debug_reg_state
*state
770 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
773 fprintf_unfiltered (gdb_stdlog
,
774 "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
775 (unsigned long) addr
, len
);
777 gdb_assert (type
!= hw_execute
);
779 ret
= aarch64_handle_watchpoint (type
, addr
, len
, 0 /* is_insert */, state
);
783 aarch64_show_debug_reg_state (state
,
784 "remove_watchpoint", addr
, len
, type
);
790 /* Implement the "region_ok_for_hw_watchpoint" target_ops method. */
793 aarch64_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
795 return aarch64_linux_region_ok_for_watchpoint (addr
, len
);
798 /* Implement the "stopped_data_address" target_ops method. */
801 aarch64_linux_nat_target::stopped_data_address (CORE_ADDR
*addr_p
)
805 struct aarch64_debug_reg_state
*state
;
807 if (!linux_nat_get_siginfo (inferior_ptid
, &siginfo
))
810 /* This must be a hardware breakpoint. */
811 if (siginfo
.si_signo
!= SIGTRAP
812 || (siginfo
.si_code
& 0xffff) != TRAP_HWBKPT
)
815 /* Check if the address matches any watched address. */
816 state
= aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
817 for (i
= aarch64_num_wp_regs
- 1; i
>= 0; --i
)
819 const unsigned int offset
820 = aarch64_watchpoint_offset (state
->dr_ctrl_wp
[i
]);
821 const unsigned int len
= aarch64_watchpoint_length (state
->dr_ctrl_wp
[i
]);
822 const CORE_ADDR addr_trap
= (CORE_ADDR
) siginfo
.si_addr
;
823 const CORE_ADDR addr_watch
= state
->dr_addr_wp
[i
] + offset
;
824 const CORE_ADDR addr_watch_aligned
= align_down (state
->dr_addr_wp
[i
], 8);
825 const CORE_ADDR addr_orig
= state
->dr_addr_orig_wp
[i
];
827 if (state
->dr_ref_count_wp
[i
]
828 && DR_CONTROL_ENABLED (state
->dr_ctrl_wp
[i
])
829 && addr_trap
>= addr_watch_aligned
830 && addr_trap
< addr_watch
+ len
)
832 /* ADDR_TRAP reports the first address of the memory range
833 accessed by the CPU, regardless of what was the memory
834 range watched. Thus, a large CPU access that straddles
835 the ADDR_WATCH..ADDR_WATCH+LEN range may result in an
836 ADDR_TRAP that is lower than the
837 ADDR_WATCH..ADDR_WATCH+LEN range. E.g.:
839 addr: | 4 | 5 | 6 | 7 | 8 |
840 |---- range watched ----|
841 |----------- range accessed ------------|
843 In this case, ADDR_TRAP will be 4.
845 To match a watchpoint known to GDB core, we must never
846 report *ADDR_P outside of any ADDR_WATCH..ADDR_WATCH+LEN
847 range. ADDR_WATCH <= ADDR_TRAP < ADDR_ORIG is a false
848 positive on kernels older than 4.10. See PR
858 /* Implement the "stopped_by_watchpoint" target_ops method. */
861 aarch64_linux_nat_target::stopped_by_watchpoint ()
865 return stopped_data_address (&addr
);
868 /* Implement the "watchpoint_addr_within_range" target_ops method. */
871 aarch64_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr
,
872 CORE_ADDR start
, int length
)
874 return start
<= addr
&& start
+ length
- 1 >= addr
;
877 /* Implement the "can_do_single_step" target_ops method. */
880 aarch64_linux_nat_target::can_do_single_step ()
885 /* Define AArch64 maintenance commands. */
888 add_show_debug_regs_command (void)
890 /* A maintenance command to enable printing the internal DRi mirror
892 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance
,
893 &show_debug_regs
, _("\
894 Set whether to show variables that mirror the AArch64 debug registers."), _("\
895 Show whether to show variables that mirror the AArch64 debug registers."), _("\
896 Use \"on\" to enable, \"off\" to disable.\n\
897 If enabled, the debug registers values are shown when GDB inserts\n\
898 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
899 triggers a breakpoint or watchpoint."),
902 &maintenance_set_cmdlist
,
903 &maintenance_show_cmdlist
);
907 _initialize_aarch64_linux_nat (void)
909 add_show_debug_regs_command ();
911 /* Register the target. */
912 linux_target
= &the_aarch64_linux_nat_target
;
913 add_inf_child_target (&the_aarch64_linux_nat_target
);