1 /* Native-dependent code for GNU/Linux AArch64.
3 Copyright (C) 2011-2015 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"
36 #include "elf/external.h"
37 #include "elf/common.h"
39 #include "nat/gdb_ptrace.h"
40 #include <sys/utsname.h>
41 #include <asm/ptrace.h>
45 /* Defines ps_err_e, struct ps_prochandle. */
46 #include "gdb_proc_service.h"
49 #define TRAP_HWBKPT 0x0004
52 /* Per-process data. We don't bind this to a per-inferior registry
53 because of targets like x86 GNU/Linux that need to keep track of
54 processes that aren't bound to any inferior (e.g., fork children,
57 struct aarch64_process_info
60 struct aarch64_process_info
*next
;
62 /* The process identifier. */
65 /* Copy of aarch64 hardware debug registers. */
66 struct aarch64_debug_reg_state state
;
69 static struct aarch64_process_info
*aarch64_process_list
= NULL
;
71 /* Find process data for process PID. */
73 static struct aarch64_process_info
*
74 aarch64_find_process_pid (pid_t pid
)
76 struct aarch64_process_info
*proc
;
78 for (proc
= aarch64_process_list
; proc
; proc
= proc
->next
)
85 /* Add process data for process PID. Returns newly allocated info
88 static struct aarch64_process_info
*
89 aarch64_add_process (pid_t pid
)
91 struct aarch64_process_info
*proc
;
93 proc
= xcalloc (1, sizeof (*proc
));
96 proc
->next
= aarch64_process_list
;
97 aarch64_process_list
= proc
;
102 /* Get data specific info for process PID, creating it if necessary.
103 Never returns NULL. */
105 static struct aarch64_process_info
*
106 aarch64_process_info_get (pid_t pid
)
108 struct aarch64_process_info
*proc
;
110 proc
= aarch64_find_process_pid (pid
);
112 proc
= aarch64_add_process (pid
);
117 /* Called whenever GDB is no longer debugging process PID. It deletes
118 data structures that keep track of debug register state. */
121 aarch64_forget_process (pid_t pid
)
123 struct aarch64_process_info
*proc
, **proc_link
;
125 proc
= aarch64_process_list
;
126 proc_link
= &aarch64_process_list
;
130 if (proc
->pid
== pid
)
132 *proc_link
= proc
->next
;
138 proc_link
= &proc
->next
;
143 /* Get debug registers state for process PID. */
145 struct aarch64_debug_reg_state
*
146 aarch64_get_debug_reg_state (pid_t pid
)
148 return &aarch64_process_info_get (pid
)->state
;
151 /* Fill GDB's register array with the general-purpose register values
152 from the current thread. */
155 fetch_gregs_from_thread (struct regcache
*regcache
)
158 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
162 /* Make sure REGS can hold all registers contents on both aarch64
164 gdb_static_assert (sizeof (regs
) >= 18 * 4);
166 tid
= ptid_get_lwp (inferior_ptid
);
168 iovec
.iov_base
= ®s
;
169 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
170 iovec
.iov_len
= 18 * 4;
172 iovec
.iov_len
= sizeof (regs
);
174 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
176 perror_with_name (_("Unable to fetch general registers."));
178 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
179 aarch32_gp_regcache_supply (regcache
, (uint32_t *) regs
, 1);
184 for (regno
= AARCH64_X0_REGNUM
; regno
<= AARCH64_CPSR_REGNUM
; regno
++)
185 regcache_raw_supply (regcache
, regno
, ®s
[regno
- AARCH64_X0_REGNUM
]);
189 /* Store to the current thread the valid general-purpose register
190 values in the GDB's register array. */
193 store_gregs_to_thread (const struct regcache
*regcache
)
198 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
200 /* Make sure REGS can hold all registers contents on both aarch64
202 gdb_static_assert (sizeof (regs
) >= 18 * 4);
203 tid
= ptid_get_lwp (inferior_ptid
);
205 iovec
.iov_base
= ®s
;
206 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
207 iovec
.iov_len
= 18 * 4;
209 iovec
.iov_len
= sizeof (regs
);
211 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
213 perror_with_name (_("Unable to fetch general registers."));
215 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
216 aarch32_gp_regcache_collect (regcache
, (uint32_t *) regs
, 1);
221 for (regno
= AARCH64_X0_REGNUM
; regno
<= AARCH64_CPSR_REGNUM
; regno
++)
222 if (REG_VALID
== regcache_register_status (regcache
, regno
))
223 regcache_raw_collect (regcache
, regno
,
224 ®s
[regno
- AARCH64_X0_REGNUM
]);
227 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_PRSTATUS
, &iovec
);
229 perror_with_name (_("Unable to store general registers."));
232 /* Fill GDB's register array with the fp/simd register values
233 from the current thread. */
236 fetch_fpregs_from_thread (struct regcache
*regcache
)
241 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
243 /* Make sure REGS can hold all VFP registers contents on both aarch64
245 gdb_static_assert (sizeof regs
>= VFP_REGS_SIZE
);
247 tid
= ptid_get_lwp (inferior_ptid
);
249 iovec
.iov_base
= ®s
;
251 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
253 iovec
.iov_len
= VFP_REGS_SIZE
;
255 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
257 perror_with_name (_("Unable to fetch VFP registers."));
259 aarch32_vfp_regcache_supply (regcache
, (gdb_byte
*) ®s
, 32);
265 iovec
.iov_len
= sizeof (regs
);
267 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iovec
);
269 perror_with_name (_("Unable to fetch vFP/SIMD registers."));
271 for (regno
= AARCH64_V0_REGNUM
; regno
<= AARCH64_V31_REGNUM
; regno
++)
272 regcache_raw_supply (regcache
, regno
,
273 ®s
.vregs
[regno
- AARCH64_V0_REGNUM
]);
275 regcache_raw_supply (regcache
, AARCH64_FPSR_REGNUM
, ®s
.fpsr
);
276 regcache_raw_supply (regcache
, AARCH64_FPCR_REGNUM
, ®s
.fpcr
);
280 /* Store to the current thread the valid fp/simd register
281 values in the GDB's register array. */
284 store_fpregs_to_thread (const struct regcache
*regcache
)
289 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
291 /* Make sure REGS can hold all VFP registers contents on both aarch64
293 gdb_static_assert (sizeof regs
>= VFP_REGS_SIZE
);
294 tid
= ptid_get_lwp (inferior_ptid
);
296 iovec
.iov_base
= ®s
;
298 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
300 iovec
.iov_len
= VFP_REGS_SIZE
;
302 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
304 perror_with_name (_("Unable to fetch VFP registers."));
306 aarch32_vfp_regcache_collect (regcache
, (gdb_byte
*) ®s
, 32);
312 iovec
.iov_len
= sizeof (regs
);
314 ret
= ptrace (PTRACE_GETREGSET
, tid
, NT_FPREGSET
, &iovec
);
316 perror_with_name (_("Unable to fetch FP/SIMD registers."));
318 for (regno
= AARCH64_V0_REGNUM
; regno
<= AARCH64_V31_REGNUM
; regno
++)
319 if (REG_VALID
== regcache_register_status (regcache
, regno
))
320 regcache_raw_collect (regcache
, regno
,
321 (char *) ®s
.vregs
[regno
- AARCH64_V0_REGNUM
]);
323 if (REG_VALID
== regcache_register_status (regcache
, AARCH64_FPSR_REGNUM
))
324 regcache_raw_collect (regcache
, AARCH64_FPSR_REGNUM
,
325 (char *) ®s
.fpsr
);
326 if (REG_VALID
== regcache_register_status (regcache
, AARCH64_FPCR_REGNUM
))
327 regcache_raw_collect (regcache
, AARCH64_FPCR_REGNUM
,
328 (char *) ®s
.fpcr
);
331 if (gdbarch_bfd_arch_info (gdbarch
)->bits_per_word
== 32)
333 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_ARM_VFP
, &iovec
);
335 perror_with_name (_("Unable to store VFP registers."));
339 ret
= ptrace (PTRACE_SETREGSET
, tid
, NT_FPREGSET
, &iovec
);
341 perror_with_name (_("Unable to store FP/SIMD registers."));
345 /* Implement the "to_fetch_register" target_ops method. */
348 aarch64_linux_fetch_inferior_registers (struct target_ops
*ops
,
349 struct regcache
*regcache
,
354 fetch_gregs_from_thread (regcache
);
355 fetch_fpregs_from_thread (regcache
);
357 else if (regno
< AARCH64_V0_REGNUM
)
358 fetch_gregs_from_thread (regcache
);
360 fetch_fpregs_from_thread (regcache
);
363 /* Implement the "to_store_register" target_ops method. */
366 aarch64_linux_store_inferior_registers (struct target_ops
*ops
,
367 struct regcache
*regcache
,
372 store_gregs_to_thread (regcache
);
373 store_fpregs_to_thread (regcache
);
375 else if (regno
< AARCH64_V0_REGNUM
)
376 store_gregs_to_thread (regcache
);
378 store_fpregs_to_thread (regcache
);
381 /* Fill register REGNO (if it is a general-purpose register) in
382 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
383 do this for all registers. */
386 fill_gregset (const struct regcache
*regcache
,
387 gdb_gregset_t
*gregsetp
, int regno
)
389 regcache_collect_regset (&aarch64_linux_gregset
, regcache
,
390 regno
, (gdb_byte
*) gregsetp
,
391 AARCH64_LINUX_SIZEOF_GREGSET
);
394 /* Fill GDB's register array with the general-purpose register values
398 supply_gregset (struct regcache
*regcache
, const gdb_gregset_t
*gregsetp
)
400 regcache_supply_regset (&aarch64_linux_gregset
, regcache
, -1,
401 (const gdb_byte
*) gregsetp
,
402 AARCH64_LINUX_SIZEOF_GREGSET
);
405 /* Fill register REGNO (if it is a floating-point register) in
406 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
407 do this for all registers. */
410 fill_fpregset (const struct regcache
*regcache
,
411 gdb_fpregset_t
*fpregsetp
, int regno
)
413 regcache_collect_regset (&aarch64_linux_fpregset
, regcache
,
414 regno
, (gdb_byte
*) fpregsetp
,
415 AARCH64_LINUX_SIZEOF_FPREGSET
);
418 /* Fill GDB's register array with the floating-point register values
422 supply_fpregset (struct regcache
*regcache
, const gdb_fpregset_t
*fpregsetp
)
424 regcache_supply_regset (&aarch64_linux_fpregset
, regcache
, -1,
425 (const gdb_byte
*) fpregsetp
,
426 AARCH64_LINUX_SIZEOF_FPREGSET
);
430 aarch64_linux_new_thread (struct lwp_info
*lp
)
432 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
434 /* Mark that all the hardware breakpoint/watchpoint register pairs
435 for this thread need to be initialized. */
436 DR_MARK_ALL_CHANGED (info
->dr_changed_bp
, aarch64_num_bp_regs
);
437 DR_MARK_ALL_CHANGED (info
->dr_changed_wp
, aarch64_num_wp_regs
);
439 lp
->arch_private
= info
;
442 /* linux_nat_new_fork hook. */
445 aarch64_linux_new_fork (struct lwp_info
*parent
, pid_t child_pid
)
448 struct aarch64_debug_reg_state
*parent_state
;
449 struct aarch64_debug_reg_state
*child_state
;
451 /* NULL means no watchpoint has ever been set in the parent. In
452 that case, there's nothing to do. */
453 if (parent
->arch_private
== NULL
)
456 /* GDB core assumes the child inherits the watchpoints/hw
457 breakpoints of the parent, and will remove them all from the
458 forked off process. Copy the debug registers mirrors into the
459 new process so that all breakpoints and watchpoints can be
462 parent_pid
= ptid_get_pid (parent
->ptid
);
463 parent_state
= aarch64_get_debug_reg_state (parent_pid
);
464 child_state
= aarch64_get_debug_reg_state (child_pid
);
465 *child_state
= *parent_state
;
469 /* Called by libthread_db. Returns a pointer to the thread local
470 storage (or its descriptor). */
473 ps_get_thread_area (const struct ps_prochandle
*ph
,
474 lwpid_t lwpid
, int idx
, void **base
)
479 iovec
.iov_base
= ®
;
480 iovec
.iov_len
= sizeof (reg
);
482 if (ptrace (PTRACE_GETREGSET
, lwpid
, NT_ARM_TLS
, &iovec
) != 0)
485 /* IDX is the bias from the thread pointer to the beginning of the
486 thread descriptor. It has to be subtracted due to implementation
487 quirks in libthread_db. */
488 *base
= (void *) (reg
- idx
);
494 static void (*super_post_startup_inferior
) (struct target_ops
*self
,
497 /* Implement the "to_post_startup_inferior" target_ops method. */
500 aarch64_linux_child_post_startup_inferior (struct target_ops
*self
,
503 aarch64_forget_process (ptid_get_pid (ptid
));
504 aarch64_linux_get_debug_reg_capacity (ptid_get_pid (ptid
));
505 super_post_startup_inferior (self
, ptid
);
508 extern struct target_desc
*tdesc_arm_with_vfpv3
;
509 extern struct target_desc
*tdesc_arm_with_neon
;
511 /* Implement the "to_read_description" target_ops method. */
513 static const struct target_desc
*
514 aarch64_linux_read_description (struct target_ops
*ops
)
518 if (target_auxv_search (ops
, AT_PHENT
, &at_phent
) == 1)
520 if (at_phent
== sizeof (Elf64_External_Phdr
))
521 return tdesc_aarch64
;
524 CORE_ADDR arm_hwcap
= 0;
526 if (target_auxv_search (ops
, AT_HWCAP
, &arm_hwcap
) != 1)
527 return ops
->beneath
->to_read_description (ops
->beneath
);
529 #ifndef COMPAT_HWCAP_VFP
530 #define COMPAT_HWCAP_VFP (1 << 6)
532 #ifndef COMPAT_HWCAP_NEON
533 #define COMPAT_HWCAP_NEON (1 << 12)
535 #ifndef COMPAT_HWCAP_VFPv3
536 #define COMPAT_HWCAP_VFPv3 (1 << 13)
539 if (arm_hwcap
& COMPAT_HWCAP_VFP
)
542 const struct target_desc
*result
= NULL
;
544 if (arm_hwcap
& COMPAT_HWCAP_NEON
)
545 result
= tdesc_arm_with_neon
;
546 else if (arm_hwcap
& COMPAT_HWCAP_VFPv3
)
547 result
= tdesc_arm_with_vfpv3
;
556 return tdesc_aarch64
;
559 /* Returns the number of hardware watchpoints of type TYPE that we can
560 set. Value is positive if we can set CNT watchpoints, zero if
561 setting watchpoints of type TYPE is not supported, and negative if
562 CNT is more than the maximum number of watchpoints of type TYPE
563 that we can support. TYPE is one of bp_hardware_watchpoint,
564 bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
565 CNT is the number of such watchpoints used so far (including this
566 one). OTHERTYPE is non-zero if other types of watchpoints are
567 currently enabled. */
570 aarch64_linux_can_use_hw_breakpoint (struct target_ops
*self
,
572 int cnt
, int othertype
)
574 if (type
== bp_hardware_watchpoint
|| type
== bp_read_watchpoint
575 || type
== bp_access_watchpoint
|| type
== bp_watchpoint
)
577 if (aarch64_num_wp_regs
== 0)
580 else if (type
== bp_hardware_breakpoint
)
582 if (aarch64_num_bp_regs
== 0)
586 gdb_assert_not_reached ("unexpected breakpoint type");
588 /* We always return 1 here because we don't have enough information
589 about possible overlap of addresses that they want to watch. As an
590 extreme example, consider the case where all the watchpoints watch
591 the same address and the same region length: then we can handle a
592 virtually unlimited number of watchpoints, due to debug register
593 sharing implemented via reference counts. */
597 /* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address.
598 Return 0 on success, -1 on failure. */
601 aarch64_linux_insert_hw_breakpoint (struct target_ops
*self
,
602 struct gdbarch
*gdbarch
,
603 struct bp_target_info
*bp_tgt
)
606 CORE_ADDR addr
= bp_tgt
->placed_address
= bp_tgt
->reqstd_address
;
608 const enum target_hw_bp_type type
= hw_execute
;
609 struct aarch64_debug_reg_state
*state
610 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
615 "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
616 (unsigned long) addr
, len
);
618 ret
= aarch64_handle_breakpoint (type
, addr
, len
, 1 /* is_insert */, state
);
622 aarch64_show_debug_reg_state (state
,
623 "insert_hw_breakpoint", addr
, len
, type
);
629 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
630 Return 0 on success, -1 on failure. */
633 aarch64_linux_remove_hw_breakpoint (struct target_ops
*self
,
634 struct gdbarch
*gdbarch
,
635 struct bp_target_info
*bp_tgt
)
638 CORE_ADDR addr
= bp_tgt
->placed_address
;
640 const enum target_hw_bp_type type
= hw_execute
;
641 struct aarch64_debug_reg_state
*state
642 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
646 (gdb_stdlog
, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
647 (unsigned long) addr
, len
);
649 ret
= aarch64_handle_breakpoint (type
, addr
, len
, 0 /* is_insert */, state
);
653 aarch64_show_debug_reg_state (state
,
654 "remove_hw_watchpoint", addr
, len
, type
);
660 /* Implement the "to_insert_watchpoint" target_ops method.
662 Insert a watchpoint to watch a memory region which starts at
663 address ADDR and whose length is LEN bytes. Watch memory accesses
664 of the type TYPE. Return 0 on success, -1 on failure. */
667 aarch64_linux_insert_watchpoint (struct target_ops
*self
,
668 CORE_ADDR addr
, int len
,
669 enum target_hw_bp_type type
,
670 struct expression
*cond
)
673 struct aarch64_debug_reg_state
*state
674 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
677 fprintf_unfiltered (gdb_stdlog
,
678 "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
679 (unsigned long) addr
, len
);
681 gdb_assert (type
!= hw_execute
);
683 ret
= aarch64_handle_watchpoint (type
, addr
, len
, 1 /* is_insert */, state
);
687 aarch64_show_debug_reg_state (state
,
688 "insert_watchpoint", addr
, len
, type
);
694 /* Implement the "to_remove_watchpoint" target_ops method.
695 Remove a watchpoint that watched the memory region which starts at
696 address ADDR, whose length is LEN bytes, and for accesses of the
697 type TYPE. Return 0 on success, -1 on failure. */
700 aarch64_linux_remove_watchpoint (struct target_ops
*self
,
701 CORE_ADDR addr
, int len
,
702 enum target_hw_bp_type type
,
703 struct expression
*cond
)
706 struct aarch64_debug_reg_state
*state
707 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
710 fprintf_unfiltered (gdb_stdlog
,
711 "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
712 (unsigned long) addr
, len
);
714 gdb_assert (type
!= hw_execute
);
716 ret
= aarch64_handle_watchpoint (type
, addr
, len
, 0 /* is_insert */, state
);
720 aarch64_show_debug_reg_state (state
,
721 "remove_watchpoint", addr
, len
, type
);
727 /* Implement the "to_region_ok_for_hw_watchpoint" target_ops method. */
730 aarch64_linux_region_ok_for_hw_watchpoint (struct target_ops
*self
,
731 CORE_ADDR addr
, int len
)
733 CORE_ADDR aligned_addr
;
735 /* Can not set watchpoints for zero or negative lengths. */
739 /* Must have hardware watchpoint debug register(s). */
740 if (aarch64_num_wp_regs
== 0)
743 /* We support unaligned watchpoint address and arbitrary length,
744 as long as the size of the whole watched area after alignment
745 doesn't exceed size of the total area that all watchpoint debug
746 registers can watch cooperatively.
748 This is a very relaxed rule, but unfortunately there are
749 limitations, e.g. false-positive hits, due to limited support of
750 hardware debug registers in the kernel. See comment above
751 aarch64_align_watchpoint for more information. */
753 aligned_addr
= addr
& ~(AARCH64_HWP_MAX_LEN_PER_REG
- 1);
754 if (aligned_addr
+ aarch64_num_wp_regs
* AARCH64_HWP_MAX_LEN_PER_REG
758 /* All tests passed so we are likely to be able to set the watchpoint.
759 The reason that it is 'likely' rather than 'must' is because
760 we don't check the current usage of the watchpoint registers, and
761 there may not be enough registers available for this watchpoint.
762 Ideally we should check the cached debug register state, however
763 the checking is costly. */
767 /* Implement the "to_stopped_data_address" target_ops method. */
770 aarch64_linux_stopped_data_address (struct target_ops
*target
,
775 struct aarch64_debug_reg_state
*state
;
777 if (!linux_nat_get_siginfo (inferior_ptid
, &siginfo
))
780 /* This must be a hardware breakpoint. */
781 if (siginfo
.si_signo
!= SIGTRAP
782 || (siginfo
.si_code
& 0xffff) != TRAP_HWBKPT
)
785 /* Check if the address matches any watched address. */
786 state
= aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid
));
787 for (i
= aarch64_num_wp_regs
- 1; i
>= 0; --i
)
789 const unsigned int len
= aarch64_watchpoint_length (state
->dr_ctrl_wp
[i
]);
790 const CORE_ADDR addr_trap
= (CORE_ADDR
) siginfo
.si_addr
;
791 const CORE_ADDR addr_watch
= state
->dr_addr_wp
[i
];
793 if (state
->dr_ref_count_wp
[i
]
794 && DR_CONTROL_ENABLED (state
->dr_ctrl_wp
[i
])
795 && addr_trap
>= addr_watch
796 && addr_trap
< addr_watch
+ len
)
806 /* Implement the "to_stopped_by_watchpoint" target_ops method. */
809 aarch64_linux_stopped_by_watchpoint (struct target_ops
*ops
)
813 return aarch64_linux_stopped_data_address (ops
, &addr
);
816 /* Implement the "to_watchpoint_addr_within_range" target_ops method. */
819 aarch64_linux_watchpoint_addr_within_range (struct target_ops
*target
,
821 CORE_ADDR start
, int length
)
823 return start
<= addr
&& start
+ length
- 1 >= addr
;
826 /* Define AArch64 maintenance commands. */
829 add_show_debug_regs_command (void)
831 /* A maintenance command to enable printing the internal DRi mirror
833 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance
,
834 &show_debug_regs
, _("\
835 Set whether to show variables that mirror the AArch64 debug registers."), _("\
836 Show whether to show variables that mirror the AArch64 debug registers."), _("\
837 Use \"on\" to enable, \"off\" to disable.\n\
838 If enabled, the debug registers values are shown when GDB inserts\n\
839 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
840 triggers a breakpoint or watchpoint."),
843 &maintenance_set_cmdlist
,
844 &maintenance_show_cmdlist
);
847 /* -Wmissing-prototypes. */
848 void _initialize_aarch64_linux_nat (void);
851 _initialize_aarch64_linux_nat (void)
853 struct target_ops
*t
;
855 /* Fill in the generic GNU/Linux methods. */
858 add_show_debug_regs_command ();
860 /* Add our register access methods. */
861 t
->to_fetch_registers
= aarch64_linux_fetch_inferior_registers
;
862 t
->to_store_registers
= aarch64_linux_store_inferior_registers
;
864 t
->to_read_description
= aarch64_linux_read_description
;
866 t
->to_can_use_hw_breakpoint
= aarch64_linux_can_use_hw_breakpoint
;
867 t
->to_insert_hw_breakpoint
= aarch64_linux_insert_hw_breakpoint
;
868 t
->to_remove_hw_breakpoint
= aarch64_linux_remove_hw_breakpoint
;
869 t
->to_region_ok_for_hw_watchpoint
=
870 aarch64_linux_region_ok_for_hw_watchpoint
;
871 t
->to_insert_watchpoint
= aarch64_linux_insert_watchpoint
;
872 t
->to_remove_watchpoint
= aarch64_linux_remove_watchpoint
;
873 t
->to_stopped_by_watchpoint
= aarch64_linux_stopped_by_watchpoint
;
874 t
->to_stopped_data_address
= aarch64_linux_stopped_data_address
;
875 t
->to_watchpoint_addr_within_range
=
876 aarch64_linux_watchpoint_addr_within_range
;
878 /* Override the GNU/Linux inferior startup hook. */
879 super_post_startup_inferior
= t
->to_post_startup_inferior
;
880 t
->to_post_startup_inferior
= aarch64_linux_child_post_startup_inferior
;
882 /* Register the target. */
883 linux_nat_add_target (t
);
884 linux_nat_set_new_thread (t
, aarch64_linux_new_thread
);
885 linux_nat_set_new_fork (t
, aarch64_linux_new_fork
);
886 linux_nat_set_forget_process (t
, aarch64_forget_process
);
887 linux_nat_set_prepare_to_resume (t
, aarch64_linux_prepare_to_resume
);