1 /* Native-dependent code for GNU/Linux AArch64.
3 Copyright (C) 2011-2019 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>
45 #include "linux-tdep.h"
47 /* Defines ps_err_e, struct ps_prochandle. */
48 #include "gdb_proc_service.h"
49 #include "arch-utils.h"
52 #define TRAP_HWBKPT 0x0004
55 class aarch64_linux_nat_target final
: public linux_nat_target
58 /* Add our register access methods. */
59 void fetch_registers (struct regcache
*, int) override
;
60 void store_registers (struct regcache
*, int) override
;
62 const struct target_desc
*read_description () override
;
64 /* Add our hardware breakpoint and watchpoint implementation. */
65 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
66 int insert_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
67 int remove_hw_breakpoint (struct gdbarch
*, struct bp_target_info
*) override
;
68 int region_ok_for_hw_watchpoint (CORE_ADDR
, int) override
;
69 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
70 struct expression
*) override
;
71 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
72 struct expression
*) override
;
73 bool stopped_by_watchpoint () override
;
74 bool stopped_data_address (CORE_ADDR
*) override
;
75 bool watchpoint_addr_within_range (CORE_ADDR
, CORE_ADDR
, int) override
;
77 int can_do_single_step () override
;
79 /* Override the GNU/Linux inferior startup hook. */
80 void post_startup_inferior (ptid_t
) override
;
82 /* Override the GNU/Linux post attach hook. */
83 void post_attach (int pid
) override
;
85 /* These three defer to common nat/ code. */
86 void low_new_thread (struct lwp_info
*lp
) override
87 { aarch64_linux_new_thread (lp
); }
88 void low_delete_thread (struct arch_lwp_info
*lp
) override
89 { aarch64_linux_delete_thread (lp
); }
90 void low_prepare_to_resume (struct lwp_info
*lp
) override
91 { aarch64_linux_prepare_to_resume (lp
); }
93 void low_new_fork (struct lwp_info
*parent
, pid_t child_pid
) override
;
94 void low_forget_process (pid_t pid
) override
;
96 /* Add our siginfo layout converter. */
97 bool low_siginfo_fixup (siginfo_t
*ptrace
, gdb_byte
*inf
, int direction
)
100 struct gdbarch
*thread_architecture (ptid_t
) override
;
103 static aarch64_linux_nat_target the_aarch64_linux_nat_target
;
105 /* Per-process data. We don't bind this to a per-inferior registry
106 because of targets like x86 GNU/Linux that need to keep track of
107 processes that aren't bound to any inferior (e.g., fork children,
110 struct aarch64_process_info
113 struct aarch64_process_info
*next
;
115 /* The process identifier. */
118 /* Copy of aarch64 hardware debug registers. */
119 struct aarch64_debug_reg_state state
;
122 static struct aarch64_process_info
*aarch64_process_list
= NULL
;
124 /* Find process data for process PID. */
126 static struct aarch64_process_info
*
127 aarch64_find_process_pid (pid_t pid
)
129 struct aarch64_process_info
*proc
;
131 for (proc
= aarch64_process_list
; proc
; proc
= proc
->next
)
132 if (proc
->pid
== pid
)
138 /* Add process data for process PID. Returns newly allocated info
141 static struct aarch64_process_info
*
142 aarch64_add_process (pid_t pid
)
144 struct aarch64_process_info
*proc
;
146 proc
= XCNEW (struct aarch64_process_info
);
149 proc
->next
= aarch64_process_list
;
150 aarch64_process_list
= proc
;
155 /* Get data specific info for process PID, creating it if necessary.
156 Never returns NULL. */
158 static struct aarch64_process_info
*
159 aarch64_process_info_get (pid_t pid
)
161 struct aarch64_process_info
*proc
;
163 proc
= aarch64_find_process_pid (pid
);
165 proc
= aarch64_add_process (pid
);
170 /* Called whenever GDB is no longer debugging process PID. It deletes
171 data structures that keep track of debug register state. */
174 aarch64_linux_nat_target::low_forget_process (pid_t pid
)
176 struct aarch64_process_info
*proc
, **proc_link
;
178 proc
= aarch64_process_list
;
179 proc_link
= &aarch64_process_list
;
183 if (proc
->pid
== pid
)
185 *proc_link
= proc
->next
;
191 proc_link
= &proc
->next
;
196 /* Get debug registers state for process PID. */
198 struct aarch64_debug_reg_state
*
199 aarch64_get_debug_reg_state (pid_t pid
)
201 return &aarch64_process_info_get (pid
)->state
;
204 /* Fill GDB's register array with the general-purpose register values
205 from the current thread. */
208 fetch_gregs_from_thread (struct regcache
*regcache
)
211 struct gdbarch
*gdbarch
= regcache
->arch ();
215 /* Make sure REGS can hold all registers contents on both aarch64
217 gdb_static_assert (sizeof (regs
) >= 18 * 4);
219 tid
= regcache
->ptid ().lwp ();
221 iovec
.iov_base
= ®s
;
222 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
223 iovec
.iov_len
= 18 * 4;
225 iovec
.iov_len
= sizeof (regs
);
227 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
229 perror_with_name (_("Unable to fetch general registers."));
231 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
232 aarch32_gp_regcache_supply (regcache
, (uint32_t *) regs
, 1);
237 for (regno
= AARCH64_X0_REGNUM
; regno
<= AARCH64_CPSR_REGNUM
; regno
++)
238 regcache
->raw_supply (regno
, ®s
[regno
- AARCH64_X0_REGNUM
]);
242 /* Store to the current thread the valid general-purpose register
243 values in the GDB's register array. */
246 store_gregs_to_thread (const struct regcache
*regcache
)
251 struct gdbarch
*gdbarch
= regcache
->arch ();
253 /* Make sure REGS can hold all registers contents on both aarch64
255 gdb_static_assert (sizeof (regs
) >= 18 * 4);
256 tid
= regcache
->ptid ().lwp ();
258 iovec
.iov_base
= ®s
;
259 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
260 iovec
.iov_len
= 18 * 4;
262 iovec
.iov_len
= sizeof (regs
);
264 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
266 perror_with_name (_("Unable to fetch general registers."));
268 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
269 aarch32_gp_regcache_collect (regcache
, (uint32_t *) regs
, 1);
274 for (regno
= AARCH64_X0_REGNUM
; regno
<= AARCH64_CPSR_REGNUM
; regno
++)
275 if (REG_VALID
== regcache
->get_register_status (regno
))
276 regcache
->raw_collect (regno
, ®s
[regno
- AARCH64_X0_REGNUM
]);
279 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
281 perror_with_name (_("Unable to store general registers."));
284 /* Fill GDB's register array with the fp/simd register values
285 from the current thread. */
288 fetch_fpregs_from_thread (struct regcache
*regcache
)
293 struct gdbarch
*gdbarch
= regcache
->arch ();
295 /* Make sure REGS can hold all VFP registers contents on both aarch64
297 gdb_static_assert (sizeof regs
>= VFP_REGS_SIZE
);
299 tid
= regcache
->ptid ().lwp ();
301 iovec
.iov_base
= ®s
;
303 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
305 iovec
.iov_len
= VFP_REGS_SIZE
;
307 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
309 perror_with_name (_("Unable to fetch VFP registers."));
311 aarch32_vfp_regcache_supply (regcache
, (gdb_byte
*) ®s
, 32);
317 iovec
.iov_len
= sizeof (regs
);
319 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iovec
);
321 perror_with_name (_("Unable to fetch vFP/SIMD registers."));
323 for (regno
= AARCH64_V0_REGNUM
; regno
<= AARCH64_V31_REGNUM
; regno
++)
324 regcache
->raw_supply (regno
, ®s
.vregs
[regno
- AARCH64_V0_REGNUM
]);
326 regcache
->raw_supply (AARCH64_FPSR_REGNUM
, ®s
.fpsr
);
327 regcache
->raw_supply (AARCH64_FPCR_REGNUM
, ®s
.fpcr
);
331 /* Store to the current thread the valid fp/simd register
332 values in the GDB's register array. */
335 store_fpregs_to_thread (const struct regcache
*regcache
)
340 struct gdbarch
*gdbarch
= regcache
->arch ();
342 /* Make sure REGS can hold all VFP registers contents on both aarch64
344 gdb_static_assert (sizeof regs
>= VFP_REGS_SIZE
);
345 tid
= regcache
->ptid ().lwp ();
347 iovec
.iov_base
= ®s
;
349 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
351 iovec
.iov_len
= VFP_REGS_SIZE
;
353 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
355 perror_with_name (_("Unable to fetch VFP registers."));
357 aarch32_vfp_regcache_collect (regcache
, (gdb_byte
*) ®s
, 32);
363 iovec
.iov_len
= sizeof (regs
);
365 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iovec
);
367 perror_with_name (_("Unable to fetch FP/SIMD registers."));
369 for (regno
= AARCH64_V0_REGNUM
; regno
<= AARCH64_V31_REGNUM
; regno
++)
370 if (REG_VALID
== regcache
->get_register_status (regno
))
371 regcache
->raw_collect
372 (regno
, (char *) ®s
.vregs
[regno
- AARCH64_V0_REGNUM
]);
374 if (REG_VALID
== regcache
->get_register_status (AARCH64_FPSR_REGNUM
))
375 regcache
->raw_collect (AARCH64_FPSR_REGNUM
, (char *) ®s
.fpsr
);
376 if (REG_VALID
== regcache
->get_register_status (AARCH64_FPCR_REGNUM
))
377 regcache
->raw_collect (AARCH64_FPCR_REGNUM
, (char *) ®s
.fpcr
);
380 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
382 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
384 perror_with_name (_("Unable to store VFP registers."));
388 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_FPREGSET
, &iovec
);
390 perror_with_name (_("Unable to store FP/SIMD registers."));
394 /* Fill GDB's register array with the sve register values
395 from the current thread. */
398 fetch_sveregs_from_thread (struct regcache
*regcache
)
400 std::unique_ptr
<gdb_byte
[]> base
401 = aarch64_sve_get_sveregs (regcache
->ptid ().lwp ());
402 aarch64_sve_regs_copy_to_reg_buf (regcache
, base
.get ());
405 /* Store to the current thread the valid sve register
406 values in the GDB's register array. */
409 store_sveregs_to_thread (struct regcache
*regcache
)
413 int tid
= regcache
->ptid ().lwp ();
415 /* Obtain a dump of SVE registers from ptrace. */
416 std::unique_ptr
<gdb_byte
[]> base
= aarch64_sve_get_sveregs (tid
);
418 /* Overwrite with regcache state. */
419 aarch64_sve_regs_copy_from_reg_buf (regcache
, base
.get ());
421 /* Write back to the kernel. */
422 iovec
.iov_base
= base
.get ();
423 iovec
.iov_len
= ((struct user_sve_header
*) base
.get ())->size
;
424 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_ARM_SVE
, &iovec
);
427 perror_with_name (_("Unable to store sve registers"));
430 /* Fill GDB's register array with the pointer authentication mask values from
431 the current thread. */
434 fetch_pauth_masks_from_thread (struct regcache
*regcache
)
436 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
439 uint64_t pauth_regset
[2] = {0, 0};
440 int tid
= regcache
->ptid ().lwp ();
442 iovec
.iov_base
= &pauth_regset
;
443 iovec
.iov_len
= sizeof (pauth_regset
);
445 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_PAC_MASK
, &iovec
);
447 perror_with_name (_("unable to fetch pauth registers."));
449 regcache
->raw_supply (AARCH64_PAUTH_DMASK_REGNUM (tdep
->pauth_reg_base
),
451 regcache
->raw_supply (AARCH64_PAUTH_CMASK_REGNUM (tdep
->pauth_reg_base
),
455 /* Implement the "fetch_registers" target_ops method. */
458 aarch64_linux_nat_target::fetch_registers (struct regcache
*regcache
,
461 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
465 fetch_gregs_from_thread (regcache
);
466 if (tdep
->has_sve ())
467 fetch_sveregs_from_thread (regcache
);
469 fetch_fpregs_from_thread (regcache
);
471 if (tdep
->has_pauth ())
472 fetch_pauth_masks_from_thread (regcache
);
474 else if (regno
< AARCH64_V0_REGNUM
)
475 fetch_gregs_from_thread (regcache
);
476 else if (tdep
->has_sve ())
477 fetch_sveregs_from_thread (regcache
);
479 fetch_fpregs_from_thread (regcache
);
481 if (tdep
->has_pauth ())
483 if (regno
== AARCH64_PAUTH_DMASK_REGNUM (tdep
->pauth_reg_base
)
484 || regno
== AARCH64_PAUTH_CMASK_REGNUM (tdep
->pauth_reg_base
))
485 fetch_pauth_masks_from_thread (regcache
);
489 /* Implement the "store_registers" target_ops method. */
492 aarch64_linux_nat_target::store_registers (struct regcache
*regcache
,
495 struct gdbarch_tdep
*tdep
= gdbarch_tdep (regcache
->arch ());
499 store_gregs_to_thread (regcache
);
500 if (tdep
->has_sve ())
501 store_sveregs_to_thread (regcache
);
503 store_fpregs_to_thread (regcache
);
505 else if (regno
< AARCH64_V0_REGNUM
)
506 store_gregs_to_thread (regcache
);
507 else if (tdep
->has_sve ())
508 store_sveregs_to_thread (regcache
);
510 store_fpregs_to_thread (regcache
);
513 /* Fill register REGNO (if it is a general-purpose register) in
514 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
515 do this for all registers. */
518 fill_gregset (const struct regcache
*regcache
,
519 gdb_gregset_t
*gregsetp
, int regno
)
521 regcache_collect_regset (&aarch64_linux_gregset
, regcache
,
522 regno
, (gdb_byte
*) gregsetp
,
523 AARCH64_LINUX_SIZEOF_GREGSET
);
526 /* Fill GDB's register array with the general-purpose register values
530 supply_gregset (struct regcache
*regcache
, const gdb_gregset_t
*gregsetp
)
532 regcache_supply_regset (&aarch64_linux_gregset
, regcache
, -1,
533 (const gdb_byte
*) gregsetp
,
534 AARCH64_LINUX_SIZEOF_GREGSET
);
537 /* Fill register REGNO (if it is a floating-point register) in
538 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
539 do this for all registers. */
542 fill_fpregset (const struct regcache
*regcache
,
543 gdb_fpregset_t
*fpregsetp
, int regno
)
545 regcache_collect_regset (&aarch64_linux_fpregset
, regcache
,
546 regno
, (gdb_byte
*) fpregsetp
,
547 AARCH64_LINUX_SIZEOF_FPREGSET
);
550 /* Fill GDB's register array with the floating-point register values
554 supply_fpregset (struct regcache
*regcache
, const gdb_fpregset_t
*fpregsetp
)
556 regcache_supply_regset (&aarch64_linux_fpregset
, regcache
, -1,
557 (const gdb_byte
*) fpregsetp
,
558 AARCH64_LINUX_SIZEOF_FPREGSET
);
561 /* linux_nat_new_fork hook. */
564 aarch64_linux_nat_target::low_new_fork (struct lwp_info
*parent
,
568 struct aarch64_debug_reg_state
*parent_state
;
569 struct aarch64_debug_reg_state
*child_state
;
571 /* NULL means no watchpoint has ever been set in the parent. In
572 that case, there's nothing to do. */
573 if (parent
->arch_private
== NULL
)
576 /* GDB core assumes the child inherits the watchpoints/hw
577 breakpoints of the parent, and will remove them all from the
578 forked off process. Copy the debug registers mirrors into the
579 new process so that all breakpoints and watchpoints can be
582 parent_pid
= parent
->ptid
.pid ();
583 parent_state
= aarch64_get_debug_reg_state (parent_pid
);
584 child_state
= aarch64_get_debug_reg_state (child_pid
);
585 *child_state
= *parent_state
;
589 /* Called by libthread_db. Returns a pointer to the thread local
590 storage (or its descriptor). */
593 ps_get_thread_area (struct ps_prochandle
*ph
,
594 lwpid_t lwpid
, int idx
, void **base
)
597 = (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word
== 64);
599 return aarch64_ps_get_thread_area (ph
, lwpid
, idx
, base
, is_64bit_p
);
603 /* Implement the "post_startup_inferior" target_ops method. */
606 aarch64_linux_nat_target::post_startup_inferior (ptid_t ptid
)
608 low_forget_process (ptid
.pid ());
609 aarch64_linux_get_debug_reg_capacity (ptid
.pid ());
610 linux_nat_target::post_startup_inferior (ptid
);
613 /* Implement the "post_attach" target_ops method. */
616 aarch64_linux_nat_target::post_attach (int pid
)
618 low_forget_process (pid
);
619 /* Set the hardware debug register capacity. If
620 aarch64_linux_get_debug_reg_capacity is not called
621 (as it is in aarch64_linux_child_post_startup_inferior) then
622 software watchpoints will be used instead of hardware
623 watchpoints when attaching to a target. */
624 aarch64_linux_get_debug_reg_capacity (pid
);
625 linux_nat_target::post_attach (pid
);
628 extern struct target_desc
*tdesc_arm_with_neon
;
630 /* Implement the "read_description" target_ops method. */
632 const struct target_desc
*
633 aarch64_linux_nat_target::read_description ()
636 gdb_byte regbuf
[VFP_REGS_SIZE
];
639 tid
= inferior_ptid
.lwp ();
641 iovec
.iov_base
= regbuf
;
642 iovec
.iov_len
= VFP_REGS_SIZE
;
644 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
646 return tdesc_arm_with_neon
;
648 CORE_ADDR hwcap
= linux_get_hwcap (this);
650 return aarch64_read_description (aarch64_sve_get_vq (tid
),
651 hwcap
& AARCH64_HWCAP_PACA
);
654 /* Convert a native/host siginfo object, into/from the siginfo in the
655 layout of the inferiors' architecture. Returns true if any
656 conversion was done; false otherwise. If DIRECTION is 1, then copy
657 from INF to NATIVE. If DIRECTION is 0, copy from NATIVE to
661 aarch64_linux_nat_target::low_siginfo_fixup (siginfo_t
*native
, gdb_byte
*inf
,
664 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
666 /* Is the inferior 32-bit? If so, then do fixup the siginfo
668 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
671 aarch64_compat_siginfo_from_siginfo ((struct compat_siginfo
*) inf
,
674 aarch64_siginfo_from_compat_siginfo (native
,
675 (struct compat_siginfo
*) inf
);
683 /* Returns the number of hardware watchpoints of type TYPE that we can
684 set. Value is positive if we can set CNT watchpoints, zero if
685 setting watchpoints of type TYPE is not supported, and negative if
686 CNT is more than the maximum number of watchpoints of type TYPE
687 that we can support. TYPE is one of bp_hardware_watchpoint,
688 bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
689 CNT is the number of such watchpoints used so far (including this
690 one). OTHERTYPE is non-zero if other types of watchpoints are
691 currently enabled. */
694 aarch64_linux_nat_target::can_use_hw_breakpoint (enum bptype type
,
695 int cnt
, int othertype
)
697 if (type
== bp_hardware_watchpoint
|| type
== bp_read_watchpoint
698 || type
== bp_access_watchpoint
|| type
== bp_watchpoint
)
700 if (aarch64_num_wp_regs
== 0)
703 else if (type
== bp_hardware_breakpoint
)
705 if (aarch64_num_bp_regs
== 0)
709 gdb_assert_not_reached ("unexpected breakpoint type");
711 /* We always return 1 here because we don't have enough information
712 about possible overlap of addresses that they want to watch. As an
713 extreme example, consider the case where all the watchpoints watch
714 the same address and the same region length: then we can handle a
715 virtually unlimited number of watchpoints, due to debug register
716 sharing implemented via reference counts. */
720 /* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address.
721 Return 0 on success, -1 on failure. */
724 aarch64_linux_nat_target::insert_hw_breakpoint (struct gdbarch
*gdbarch
,
725 struct bp_target_info
*bp_tgt
)
728 CORE_ADDR addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
730 const enum target_hw_bp_type type
= hw_execute
;
731 struct aarch64_debug_reg_state
*state
732 = aarch64_get_debug_reg_state (inferior_ptid
.pid ());
734 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
739 "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
740 (unsigned long) addr
, len
);
742 ret
= aarch64_handle_breakpoint (type
, addr
, len
, 1 /* is_insert */, state
);
746 aarch64_show_debug_reg_state (state
,
747 "insert_hw_breakpoint", addr
, len
, type
);
753 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
754 Return 0 on success, -1 on failure. */
757 aarch64_linux_nat_target::remove_hw_breakpoint (struct gdbarch
*gdbarch
,
758 struct bp_target_info
*bp_tgt
)
761 CORE_ADDR addr
= bp_tgt
->placed_address
;
763 const enum target_hw_bp_type type
= hw_execute
;
764 struct aarch64_debug_reg_state
*state
765 = aarch64_get_debug_reg_state (inferior_ptid
.pid ());
767 gdbarch_breakpoint_from_pc (gdbarch
, &addr
, &len
);
771 (gdb_stdlog
, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
772 (unsigned long) addr
, len
);
774 ret
= aarch64_handle_breakpoint (type
, addr
, len
, 0 /* is_insert */, state
);
778 aarch64_show_debug_reg_state (state
,
779 "remove_hw_watchpoint", addr
, len
, type
);
785 /* Implement the "insert_watchpoint" target_ops method.
787 Insert a watchpoint to watch a memory region which starts at
788 address ADDR and whose length is LEN bytes. Watch memory accesses
789 of the type TYPE. Return 0 on success, -1 on failure. */
792 aarch64_linux_nat_target::insert_watchpoint (CORE_ADDR addr
, int len
,
793 enum target_hw_bp_type type
,
794 struct expression
*cond
)
797 struct aarch64_debug_reg_state
*state
798 = aarch64_get_debug_reg_state (inferior_ptid
.pid ());
801 fprintf_unfiltered (gdb_stdlog
,
802 "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
803 (unsigned long) addr
, len
);
805 gdb_assert (type
!= hw_execute
);
807 ret
= aarch64_handle_watchpoint (type
, addr
, len
, 1 /* is_insert */, state
);
811 aarch64_show_debug_reg_state (state
,
812 "insert_watchpoint", addr
, len
, type
);
818 /* Implement the "remove_watchpoint" target_ops method.
819 Remove a watchpoint that watched the memory region which starts at
820 address ADDR, whose length is LEN bytes, and for accesses of the
821 type TYPE. Return 0 on success, -1 on failure. */
824 aarch64_linux_nat_target::remove_watchpoint (CORE_ADDR addr
, int len
,
825 enum target_hw_bp_type type
,
826 struct expression
*cond
)
829 struct aarch64_debug_reg_state
*state
830 = aarch64_get_debug_reg_state (inferior_ptid
.pid ());
833 fprintf_unfiltered (gdb_stdlog
,
834 "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
835 (unsigned long) addr
, len
);
837 gdb_assert (type
!= hw_execute
);
839 ret
= aarch64_handle_watchpoint (type
, addr
, len
, 0 /* is_insert */, state
);
843 aarch64_show_debug_reg_state (state
,
844 "remove_watchpoint", addr
, len
, type
);
850 /* Implement the "region_ok_for_hw_watchpoint" target_ops method. */
853 aarch64_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr
, int len
)
855 return aarch64_linux_region_ok_for_watchpoint (addr
, len
);
858 /* Implement the "stopped_data_address" target_ops method. */
861 aarch64_linux_nat_target::stopped_data_address (CORE_ADDR
*addr_p
)
865 struct aarch64_debug_reg_state
*state
;
867 if (!linux_nat_get_siginfo (inferior_ptid
, &siginfo
))
870 /* This must be a hardware breakpoint. */
871 if (siginfo
.si_signo
!= SIGTRAP
872 || (siginfo
.si_code
& 0xffff) != TRAP_HWBKPT
)
875 /* Check if the address matches any watched address. */
876 state
= aarch64_get_debug_reg_state (inferior_ptid
.pid ());
877 for (i
= aarch64_num_wp_regs
- 1; i
>= 0; --i
)
879 const unsigned int offset
880 = aarch64_watchpoint_offset (state
->dr_ctrl_wp
[i
]);
881 const unsigned int len
= aarch64_watchpoint_length (state
->dr_ctrl_wp
[i
]);
882 const CORE_ADDR addr_trap
= (CORE_ADDR
) siginfo
.si_addr
;
883 const CORE_ADDR addr_watch
= state
->dr_addr_wp
[i
] + offset
;
884 const CORE_ADDR addr_watch_aligned
= align_down (state
->dr_addr_wp
[i
], 8);
885 const CORE_ADDR addr_orig
= state
->dr_addr_orig_wp
[i
];
887 if (state
->dr_ref_count_wp
[i
]
888 && DR_CONTROL_ENABLED (state
->dr_ctrl_wp
[i
])
889 && addr_trap
>= addr_watch_aligned
890 && addr_trap
< addr_watch
+ len
)
892 /* ADDR_TRAP reports the first address of the memory range
893 accessed by the CPU, regardless of what was the memory
894 range watched. Thus, a large CPU access that straddles
895 the ADDR_WATCH..ADDR_WATCH+LEN range may result in an
896 ADDR_TRAP that is lower than the
897 ADDR_WATCH..ADDR_WATCH+LEN range. E.g.:
899 addr: | 4 | 5 | 6 | 7 | 8 |
900 |---- range watched ----|
901 |----------- range accessed ------------|
903 In this case, ADDR_TRAP will be 4.
905 To match a watchpoint known to GDB core, we must never
906 report *ADDR_P outside of any ADDR_WATCH..ADDR_WATCH+LEN
907 range. ADDR_WATCH <= ADDR_TRAP < ADDR_ORIG is a false
908 positive on kernels older than 4.10. See PR
918 /* Implement the "stopped_by_watchpoint" target_ops method. */
921 aarch64_linux_nat_target::stopped_by_watchpoint ()
925 return stopped_data_address (&addr
);
928 /* Implement the "watchpoint_addr_within_range" target_ops method. */
931 aarch64_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr
,
932 CORE_ADDR start
, int length
)
934 return start
<= addr
&& start
+ length
- 1 >= addr
;
937 /* Implement the "can_do_single_step" target_ops method. */
940 aarch64_linux_nat_target::can_do_single_step ()
945 /* Implement the "thread_architecture" target_ops method. */
948 aarch64_linux_nat_target::thread_architecture (ptid_t ptid
)
950 /* Return the gdbarch for the current thread. If the vector length has
951 changed since the last time this was called, then do a further lookup. */
953 uint64_t vq
= aarch64_sve_get_vq (ptid
.lwp ());
955 /* Find the current gdbarch the same way as process_stratum_target. Only
956 return it if the current vector length matches the one in the tdep. */
957 inferior
*inf
= find_inferior_ptid (ptid
);
958 gdb_assert (inf
!= NULL
);
959 if (vq
== gdbarch_tdep (inf
->gdbarch
)->vq
)
962 /* We reach here if the vector length for the thread is different from its
963 value at process start. Lookup gdbarch via info (potentially creating a
964 new one), stashing the vector length inside id. Use -1 for when SVE
965 unavailable, to distinguish from an unset value of 0. */
966 struct gdbarch_info info
;
967 gdbarch_info_init (&info
);
968 info
.bfd_arch_info
= bfd_lookup_arch (bfd_arch_spu
, bfd_mach_spu
);
969 info
.id
= (int *) (vq
== 0 ? -1 : vq
);
970 return gdbarch_find_by_info (info
);
973 /* Define AArch64 maintenance commands. */
976 add_show_debug_regs_command (void)
978 /* A maintenance command to enable printing the internal DRi mirror
980 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance
,
981 &show_debug_regs
, _("\
982 Set whether to show variables that mirror the AArch64 debug registers."), _("\
983 Show whether to show variables that mirror the AArch64 debug registers."), _("\
984 Use \"on\" to enable, \"off\" to disable.\n\
985 If enabled, the debug registers values are shown when GDB inserts\n\
986 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
987 triggers a breakpoint or watchpoint."),
990 &maintenance_set_cmdlist
,
991 &maintenance_show_cmdlist
);
995 _initialize_aarch64_linux_nat (void)
997 add_show_debug_regs_command ();
999 /* Register the target. */
1000 linux_target
= &the_aarch64_linux_nat_target
;
1001 add_inf_child_target (&the_aarch64_linux_nat_target
);