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"
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 class aarch64_linux_nat_target final : public linux_nat_target
55 /* Add our register access methods. */
56 void fetch_registers (struct regcache *, int) override;
57 void store_registers (struct regcache *, int) override;
59 const struct target_desc *read_description () override;
61 /* Add our hardware breakpoint and watchpoint implementation. */
62 int can_use_hw_breakpoint (enum bptype, int, int) override;
63 int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
64 int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
65 int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
66 int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
67 struct expression *) override;
68 int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
69 struct expression *) override;
70 bool stopped_by_watchpoint () override;
71 bool stopped_data_address (CORE_ADDR *) override;
72 bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
74 int can_do_single_step () override;
76 /* Override the GNU/Linux inferior startup hook. */
77 void post_startup_inferior (ptid_t) override;
79 /* These three defer to common nat/ code. */
80 void low_new_thread (struct lwp_info *lp) override
81 { aarch64_linux_new_thread (lp); }
82 void low_delete_thread (struct arch_lwp_info *lp) override
83 { aarch64_linux_delete_thread (lp); }
84 void low_prepare_to_resume (struct lwp_info *lp) override
85 { aarch64_linux_prepare_to_resume (lp); }
87 void low_new_fork (struct lwp_info *parent, pid_t child_pid) override;
88 void low_forget_process (pid_t pid) override;
90 /* Add our siginfo layout converter. */
91 bool low_siginfo_fixup (siginfo_t *ptrace, gdb_byte *inf, int direction)
95 static aarch64_linux_nat_target the_aarch64_linux_nat_target;
97 /* Per-process data. We don't bind this to a per-inferior registry
98 because of targets like x86 GNU/Linux that need to keep track of
99 processes that aren't bound to any inferior (e.g., fork children,
102 struct aarch64_process_info
105 struct aarch64_process_info *next;
107 /* The process identifier. */
110 /* Copy of aarch64 hardware debug registers. */
111 struct aarch64_debug_reg_state state;
114 static struct aarch64_process_info *aarch64_process_list = NULL;
116 /* Find process data for process PID. */
118 static struct aarch64_process_info *
119 aarch64_find_process_pid (pid_t pid)
121 struct aarch64_process_info *proc;
123 for (proc = aarch64_process_list; proc; proc = proc->next)
124 if (proc->pid == pid)
130 /* Add process data for process PID. Returns newly allocated info
133 static struct aarch64_process_info *
134 aarch64_add_process (pid_t pid)
136 struct aarch64_process_info *proc;
138 proc = XCNEW (struct aarch64_process_info);
141 proc->next = aarch64_process_list;
142 aarch64_process_list = proc;
147 /* Get data specific info for process PID, creating it if necessary.
148 Never returns NULL. */
150 static struct aarch64_process_info *
151 aarch64_process_info_get (pid_t pid)
153 struct aarch64_process_info *proc;
155 proc = aarch64_find_process_pid (pid);
157 proc = aarch64_add_process (pid);
162 /* Called whenever GDB is no longer debugging process PID. It deletes
163 data structures that keep track of debug register state. */
166 aarch64_linux_nat_target::low_forget_process (pid_t pid)
168 struct aarch64_process_info *proc, **proc_link;
170 proc = aarch64_process_list;
171 proc_link = &aarch64_process_list;
175 if (proc->pid == pid)
177 *proc_link = proc->next;
183 proc_link = &proc->next;
188 /* Get debug registers state for process PID. */
190 struct aarch64_debug_reg_state *
191 aarch64_get_debug_reg_state (pid_t pid)
193 return &aarch64_process_info_get (pid)->state;
196 /* Fill GDB's register array with the general-purpose register values
197 from the current thread. */
200 fetch_gregs_from_thread (struct regcache *regcache)
203 struct gdbarch *gdbarch = regcache->arch ();
207 /* Make sure REGS can hold all registers contents on both aarch64
209 gdb_static_assert (sizeof (regs) >= 18 * 4);
211 tid = ptid_get_lwp (regcache_get_ptid (regcache));
213 iovec.iov_base = ®s;
214 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
215 iovec.iov_len = 18 * 4;
217 iovec.iov_len = sizeof (regs);
219 ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
221 perror_with_name (_("Unable to fetch general registers."));
223 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
224 aarch32_gp_regcache_supply (regcache, (uint32_t *) regs, 1);
229 for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
230 regcache_raw_supply (regcache, regno, ®s[regno - AARCH64_X0_REGNUM]);
234 /* Store to the current thread the valid general-purpose register
235 values in the GDB's register array. */
238 store_gregs_to_thread (const struct regcache *regcache)
243 struct gdbarch *gdbarch = regcache->arch ();
245 /* Make sure REGS can hold all registers contents on both aarch64
247 gdb_static_assert (sizeof (regs) >= 18 * 4);
248 tid = ptid_get_lwp (regcache_get_ptid (regcache));
250 iovec.iov_base = ®s;
251 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
252 iovec.iov_len = 18 * 4;
254 iovec.iov_len = sizeof (regs);
256 ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
258 perror_with_name (_("Unable to fetch general registers."));
260 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
261 aarch32_gp_regcache_collect (regcache, (uint32_t *) regs, 1);
266 for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
267 if (REG_VALID == regcache_register_status (regcache, regno))
268 regcache_raw_collect (regcache, regno,
269 ®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_get_ptid (regcache));
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 (regcache, regno,
318 ®s.vregs[regno - AARCH64_V0_REGNUM]);
320 regcache_raw_supply (regcache, AARCH64_FPSR_REGNUM, ®s.fpsr);
321 regcache_raw_supply (regcache, AARCH64_FPCR_REGNUM, ®s.fpcr);
325 /* Store to the current thread the valid fp/simd register
326 values in the GDB's register array. */
329 store_fpregs_to_thread (const struct regcache *regcache)
334 struct gdbarch *gdbarch = regcache->arch ();
336 /* Make sure REGS can hold all VFP registers contents on both aarch64
338 gdb_static_assert (sizeof regs >= VFP_REGS_SIZE);
339 tid = ptid_get_lwp (regcache_get_ptid (regcache));
341 iovec.iov_base = ®s;
343 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
345 iovec.iov_len = VFP_REGS_SIZE;
347 ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iovec);
349 perror_with_name (_("Unable to fetch VFP registers."));
351 aarch32_vfp_regcache_collect (regcache, (gdb_byte *) ®s, 32);
357 iovec.iov_len = sizeof (regs);
359 ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iovec);
361 perror_with_name (_("Unable to fetch FP/SIMD registers."));
363 for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
364 if (REG_VALID == regcache_register_status (regcache, regno))
365 regcache_raw_collect (regcache, regno,
366 (char *) ®s.vregs[regno - AARCH64_V0_REGNUM]);
368 if (REG_VALID == regcache_register_status (regcache, AARCH64_FPSR_REGNUM))
369 regcache_raw_collect (regcache, AARCH64_FPSR_REGNUM,
370 (char *) ®s.fpsr);
371 if (REG_VALID == regcache_register_status (regcache, AARCH64_FPCR_REGNUM))
372 regcache_raw_collect (regcache, AARCH64_FPCR_REGNUM,
373 (char *) ®s.fpcr);
376 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
378 ret = ptrace (PTRACE_SETREGSET, tid, NT_ARM_VFP, &iovec);
380 perror_with_name (_("Unable to store VFP registers."));
384 ret = ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, &iovec);
386 perror_with_name (_("Unable to store FP/SIMD registers."));
390 /* Implement the "fetch_registers" target_ops method. */
393 aarch64_linux_nat_target::fetch_registers (struct regcache *regcache,
398 fetch_gregs_from_thread (regcache);
399 fetch_fpregs_from_thread (regcache);
401 else if (regno < AARCH64_V0_REGNUM)
402 fetch_gregs_from_thread (regcache);
404 fetch_fpregs_from_thread (regcache);
407 /* Implement the "store_registers" target_ops method. */
410 aarch64_linux_nat_target::store_registers (struct regcache *regcache,
415 store_gregs_to_thread (regcache);
416 store_fpregs_to_thread (regcache);
418 else if (regno < AARCH64_V0_REGNUM)
419 store_gregs_to_thread (regcache);
421 store_fpregs_to_thread (regcache);
424 /* Fill register REGNO (if it is a general-purpose register) in
425 *GREGSETPS with the value in GDB's register array. If REGNO is -1,
426 do this for all registers. */
429 fill_gregset (const struct regcache *regcache,
430 gdb_gregset_t *gregsetp, int regno)
432 regcache_collect_regset (&aarch64_linux_gregset, regcache,
433 regno, (gdb_byte *) gregsetp,
434 AARCH64_LINUX_SIZEOF_GREGSET);
437 /* Fill GDB's register array with the general-purpose register values
441 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
443 regcache_supply_regset (&aarch64_linux_gregset, regcache, -1,
444 (const gdb_byte *) gregsetp,
445 AARCH64_LINUX_SIZEOF_GREGSET);
448 /* Fill register REGNO (if it is a floating-point register) in
449 *FPREGSETP with the value in GDB's register array. If REGNO is -1,
450 do this for all registers. */
453 fill_fpregset (const struct regcache *regcache,
454 gdb_fpregset_t *fpregsetp, int regno)
456 regcache_collect_regset (&aarch64_linux_fpregset, regcache,
457 regno, (gdb_byte *) fpregsetp,
458 AARCH64_LINUX_SIZEOF_FPREGSET);
461 /* Fill GDB's register array with the floating-point register values
465 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
467 regcache_supply_regset (&aarch64_linux_fpregset, regcache, -1,
468 (const gdb_byte *) fpregsetp,
469 AARCH64_LINUX_SIZEOF_FPREGSET);
472 /* linux_nat_new_fork hook. */
475 aarch64_linux_nat_target::low_new_fork (struct lwp_info *parent,
479 struct aarch64_debug_reg_state *parent_state;
480 struct aarch64_debug_reg_state *child_state;
482 /* NULL means no watchpoint has ever been set in the parent. In
483 that case, there's nothing to do. */
484 if (parent->arch_private == NULL)
487 /* GDB core assumes the child inherits the watchpoints/hw
488 breakpoints of the parent, and will remove them all from the
489 forked off process. Copy the debug registers mirrors into the
490 new process so that all breakpoints and watchpoints can be
493 parent_pid = ptid_get_pid (parent->ptid);
494 parent_state = aarch64_get_debug_reg_state (parent_pid);
495 child_state = aarch64_get_debug_reg_state (child_pid);
496 *child_state = *parent_state;
500 /* Called by libthread_db. Returns a pointer to the thread local
501 storage (or its descriptor). */
504 ps_get_thread_area (struct ps_prochandle *ph,
505 lwpid_t lwpid, int idx, void **base)
508 = (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 64);
510 return aarch64_ps_get_thread_area (ph, lwpid, idx, base, is_64bit_p);
514 /* Implement the "post_startup_inferior" target_ops method. */
517 aarch64_linux_nat_target::post_startup_inferior (ptid_t ptid)
519 low_forget_process (ptid_get_pid (ptid));
520 aarch64_linux_get_debug_reg_capacity (ptid_get_pid (ptid));
521 linux_nat_target::post_startup_inferior (ptid);
524 extern struct target_desc *tdesc_arm_with_neon;
526 /* Implement the "read_description" target_ops method. */
528 const struct target_desc *
529 aarch64_linux_nat_target::read_description ()
532 gdb_byte regbuf[VFP_REGS_SIZE];
535 tid = ptid_get_lwp (inferior_ptid);
537 iovec.iov_base = regbuf;
538 iovec.iov_len = VFP_REGS_SIZE;
540 ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iovec);
542 return tdesc_arm_with_neon;
544 return aarch64_read_description ();
547 /* Convert a native/host siginfo object, into/from the siginfo in the
548 layout of the inferiors' architecture. Returns true if any
549 conversion was done; false otherwise. If DIRECTION is 1, then copy
550 from INF to NATIVE. If DIRECTION is 0, copy from NATIVE to
554 aarch64_linux_nat_target::low_siginfo_fixup (siginfo_t *native, gdb_byte *inf,
557 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
559 /* Is the inferior 32-bit? If so, then do fixup the siginfo
561 if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
564 aarch64_compat_siginfo_from_siginfo ((struct compat_siginfo *) inf,
567 aarch64_siginfo_from_compat_siginfo (native,
568 (struct compat_siginfo *) inf);
576 /* Returns the number of hardware watchpoints of type TYPE that we can
577 set. Value is positive if we can set CNT watchpoints, zero if
578 setting watchpoints of type TYPE is not supported, and negative if
579 CNT is more than the maximum number of watchpoints of type TYPE
580 that we can support. TYPE is one of bp_hardware_watchpoint,
581 bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
582 CNT is the number of such watchpoints used so far (including this
583 one). OTHERTYPE is non-zero if other types of watchpoints are
584 currently enabled. */
587 aarch64_linux_nat_target::can_use_hw_breakpoint (enum bptype type,
588 int cnt, int othertype)
590 if (type == bp_hardware_watchpoint || type == bp_read_watchpoint
591 || type == bp_access_watchpoint || type == bp_watchpoint)
593 if (aarch64_num_wp_regs == 0)
596 else if (type == bp_hardware_breakpoint)
598 if (aarch64_num_bp_regs == 0)
602 gdb_assert_not_reached ("unexpected breakpoint type");
604 /* We always return 1 here because we don't have enough information
605 about possible overlap of addresses that they want to watch. As an
606 extreme example, consider the case where all the watchpoints watch
607 the same address and the same region length: then we can handle a
608 virtually unlimited number of watchpoints, due to debug register
609 sharing implemented via reference counts. */
613 /* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address.
614 Return 0 on success, -1 on failure. */
617 aarch64_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
618 struct bp_target_info *bp_tgt)
621 CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
623 const enum target_hw_bp_type type = hw_execute;
624 struct aarch64_debug_reg_state *state
625 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
627 gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
632 "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
633 (unsigned long) addr, len);
635 ret = aarch64_handle_breakpoint (type, addr, len, 1 /* is_insert */, state);
639 aarch64_show_debug_reg_state (state,
640 "insert_hw_breakpoint", addr, len, type);
646 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
647 Return 0 on success, -1 on failure. */
650 aarch64_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
651 struct bp_target_info *bp_tgt)
654 CORE_ADDR addr = bp_tgt->placed_address;
656 const enum target_hw_bp_type type = hw_execute;
657 struct aarch64_debug_reg_state *state
658 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
660 gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
664 (gdb_stdlog, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
665 (unsigned long) addr, len);
667 ret = aarch64_handle_breakpoint (type, addr, len, 0 /* is_insert */, state);
671 aarch64_show_debug_reg_state (state,
672 "remove_hw_watchpoint", addr, len, type);
678 /* Implement the "insert_watchpoint" target_ops method.
680 Insert a watchpoint to watch a memory region which starts at
681 address ADDR and whose length is LEN bytes. Watch memory accesses
682 of the type TYPE. Return 0 on success, -1 on failure. */
685 aarch64_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len,
686 enum target_hw_bp_type type,
687 struct expression *cond)
690 struct aarch64_debug_reg_state *state
691 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
694 fprintf_unfiltered (gdb_stdlog,
695 "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
696 (unsigned long) addr, len);
698 gdb_assert (type != hw_execute);
700 ret = aarch64_handle_watchpoint (type, addr, len, 1 /* is_insert */, state);
704 aarch64_show_debug_reg_state (state,
705 "insert_watchpoint", addr, len, type);
711 /* Implement the "remove_watchpoint" target_ops method.
712 Remove a watchpoint that watched the memory region which starts at
713 address ADDR, whose length is LEN bytes, and for accesses of the
714 type TYPE. Return 0 on success, -1 on failure. */
717 aarch64_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len,
718 enum target_hw_bp_type type,
719 struct expression *cond)
722 struct aarch64_debug_reg_state *state
723 = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
726 fprintf_unfiltered (gdb_stdlog,
727 "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
728 (unsigned long) addr, len);
730 gdb_assert (type != hw_execute);
732 ret = aarch64_handle_watchpoint (type, addr, len, 0 /* is_insert */, state);
736 aarch64_show_debug_reg_state (state,
737 "remove_watchpoint", addr, len, type);
743 /* Implement the "region_ok_for_hw_watchpoint" target_ops method. */
746 aarch64_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
748 return aarch64_linux_region_ok_for_watchpoint (addr, len);
751 /* Implement the "stopped_data_address" target_ops method. */
754 aarch64_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p)
758 struct aarch64_debug_reg_state *state;
760 if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
763 /* This must be a hardware breakpoint. */
764 if (siginfo.si_signo != SIGTRAP
765 || (siginfo.si_code & 0xffff) != TRAP_HWBKPT)
768 /* Check if the address matches any watched address. */
769 state = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
770 for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
772 const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
773 const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
774 const CORE_ADDR addr_watch = state->dr_addr_wp[i];
776 if (state->dr_ref_count_wp[i]
777 && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
778 && addr_trap >= addr_watch
779 && addr_trap < addr_watch + len)
789 /* Implement the "stopped_by_watchpoint" target_ops method. */
792 aarch64_linux_nat_target::stopped_by_watchpoint ()
796 return stopped_data_address (&addr);
799 /* Implement the "watchpoint_addr_within_range" target_ops method. */
802 aarch64_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr,
803 CORE_ADDR start, int length)
805 return start <= addr && start + length - 1 >= addr;
808 /* Implement the "can_do_single_step" target_ops method. */
811 aarch64_linux_nat_target::can_do_single_step ()
816 /* Define AArch64 maintenance commands. */
819 add_show_debug_regs_command (void)
821 /* A maintenance command to enable printing the internal DRi mirror
823 add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
824 &show_debug_regs, _("\
825 Set whether to show variables that mirror the AArch64 debug registers."), _("\
826 Show whether to show variables that mirror the AArch64 debug registers."), _("\
827 Use \"on\" to enable, \"off\" to disable.\n\
828 If enabled, the debug registers values are shown when GDB inserts\n\
829 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
830 triggers a breakpoint or watchpoint."),
833 &maintenance_set_cmdlist,
834 &maintenance_show_cmdlist);
838 _initialize_aarch64_linux_nat (void)
840 add_show_debug_regs_command ();
842 /* Register the target. */
843 linux_target = &the_aarch64_linux_nat_target;
844 add_inf_child_target (&the_aarch64_linux_nat_target);