diff options
| -rw-r--r-- | gdb/aarch64-linux-nat.c | 356 | ||||
| -rw-r--r-- | gdb/aarch64-nat.c | 302 | ||||
| -rw-r--r-- | gdb/aarch64-nat.h | 109 | ||||
| -rw-r--r-- | gdb/configure.nat | 2 |
4 files changed, 418 insertions, 351 deletions
diff --git a/gdb/aarch64-linux-nat.c b/gdb/aarch64-linux-nat.c index dd072d9..7bb82d1 100644 --- a/gdb/aarch64-linux-nat.c +++ b/gdb/aarch64-linux-nat.c @@ -27,6 +27,7 @@ #include "target-descriptions.h" #include "auxv.h" #include "gdbcmd.h" +#include "aarch64-nat.h" #include "aarch64-tdep.h" #include "aarch64-linux-tdep.h" #include "aarch32-linux-nat.h" @@ -58,7 +59,8 @@ #define TRAP_HWBKPT 0x0004 #endif -class aarch64_linux_nat_target final : public linux_nat_target +class aarch64_linux_nat_target final + : public aarch64_nat_target<linux_nat_target> { public: /* Add our register access methods. */ @@ -68,17 +70,8 @@ public: const struct target_desc *read_description () override; /* Add our hardware breakpoint and watchpoint implementation. */ - int can_use_hw_breakpoint (enum bptype, int, int) override; - int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; - int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override; - int region_ok_for_hw_watchpoint (CORE_ADDR, int) override; - int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, - struct expression *) override; - int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type, - struct expression *) override; bool stopped_by_watchpoint () override; bool stopped_data_address (CORE_ADDR *) override; - bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override; int can_do_single_step () override; @@ -118,103 +111,13 @@ public: static aarch64_linux_nat_target the_aarch64_linux_nat_target; -/* Per-process data. We don't bind this to a per-inferior registry - because of targets like x86 GNU/Linux that need to keep track of - processes that aren't bound to any inferior (e.g., fork children, - checkpoints). */ - -struct aarch64_process_info -{ - /* Linked list. */ - struct aarch64_process_info *next; - - /* The process identifier. */ - pid_t pid; - - /* Copy of aarch64 hardware debug registers. */ - struct aarch64_debug_reg_state state; -}; - -static struct aarch64_process_info *aarch64_process_list = NULL; - -/* Find process data for process PID. */ - -static struct aarch64_process_info * -aarch64_find_process_pid (pid_t pid) -{ - struct aarch64_process_info *proc; - - for (proc = aarch64_process_list; proc; proc = proc->next) - if (proc->pid == pid) - return proc; - - return NULL; -} - -/* Add process data for process PID. Returns newly allocated info - object. */ - -static struct aarch64_process_info * -aarch64_add_process (pid_t pid) -{ - struct aarch64_process_info *proc; - - proc = XCNEW (struct aarch64_process_info); - proc->pid = pid; - - proc->next = aarch64_process_list; - aarch64_process_list = proc; - - return proc; -} - -/* Get data specific info for process PID, creating it if necessary. - Never returns NULL. */ - -static struct aarch64_process_info * -aarch64_process_info_get (pid_t pid) -{ - struct aarch64_process_info *proc; - - proc = aarch64_find_process_pid (pid); - if (proc == NULL) - proc = aarch64_add_process (pid); - - return proc; -} - /* Called whenever GDB is no longer debugging process PID. It deletes data structures that keep track of debug register state. */ void aarch64_linux_nat_target::low_forget_process (pid_t pid) { - struct aarch64_process_info *proc, **proc_link; - - proc = aarch64_process_list; - proc_link = &aarch64_process_list; - - while (proc != NULL) - { - if (proc->pid == pid) - { - *proc_link = proc->next; - - xfree (proc); - return; - } - - proc_link = &proc->next; - proc = *proc_link; - } -} - -/* Get debug registers state for process PID. */ - -struct aarch64_debug_reg_state * -aarch64_get_debug_reg_state (pid_t pid) -{ - return &aarch64_process_info_get (pid)->state; + aarch64_remove_debug_reg_state (pid); } /* Fill GDB's register array with the general-purpose register values @@ -775,192 +678,12 @@ aarch64_linux_nat_target::low_siginfo_fixup (siginfo_t *native, gdb_byte *inf, return false; } -/* Returns the number of hardware watchpoints of type TYPE that we can - set. Value is positive if we can set CNT watchpoints, zero if - setting watchpoints of type TYPE is not supported, and negative if - CNT is more than the maximum number of watchpoints of type TYPE - that we can support. TYPE is one of bp_hardware_watchpoint, - bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint. - CNT is the number of such watchpoints used so far (including this - one). OTHERTYPE is non-zero if other types of watchpoints are - currently enabled. */ - -int -aarch64_linux_nat_target::can_use_hw_breakpoint (enum bptype type, - int cnt, int othertype) -{ - if (type == bp_hardware_watchpoint || type == bp_read_watchpoint - || type == bp_access_watchpoint || type == bp_watchpoint) - { - if (aarch64_num_wp_regs == 0) - return 0; - } - else if (type == bp_hardware_breakpoint) - { - if (aarch64_num_bp_regs == 0) - return 0; - } - else - gdb_assert_not_reached ("unexpected breakpoint type"); - - /* We always return 1 here because we don't have enough information - about possible overlap of addresses that they want to watch. As an - extreme example, consider the case where all the watchpoints watch - the same address and the same region length: then we can handle a - virtually unlimited number of watchpoints, due to debug register - sharing implemented via reference counts. */ - return 1; -} - -/* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address. - Return 0 on success, -1 on failure. */ - -int -aarch64_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) -{ - int ret; - CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address; - int len; - const enum target_hw_bp_type type = hw_execute; - struct aarch64_debug_reg_state *state - = aarch64_get_debug_reg_state (inferior_ptid.pid ()); - - gdbarch_breakpoint_from_pc (gdbarch, &addr, &len); - - if (show_debug_regs) - fprintf_unfiltered - (gdb_stdlog, - "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n", - (unsigned long) addr, len); - - ret = aarch64_handle_breakpoint (type, addr, len, 1 /* is_insert */, - inferior_ptid, state); - - if (show_debug_regs) - { - aarch64_show_debug_reg_state (state, - "insert_hw_breakpoint", addr, len, type); - } - - return ret; -} - -/* Remove a hardware-assisted breakpoint at BP_TGT->placed_address. - Return 0 on success, -1 on failure. */ - -int -aarch64_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch, - struct bp_target_info *bp_tgt) -{ - int ret; - CORE_ADDR addr = bp_tgt->placed_address; - int len = 4; - const enum target_hw_bp_type type = hw_execute; - struct aarch64_debug_reg_state *state - = aarch64_get_debug_reg_state (inferior_ptid.pid ()); - - gdbarch_breakpoint_from_pc (gdbarch, &addr, &len); - - if (show_debug_regs) - fprintf_unfiltered - (gdb_stdlog, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n", - (unsigned long) addr, len); - - ret = aarch64_handle_breakpoint (type, addr, len, 0 /* is_insert */, - inferior_ptid, state); - - if (show_debug_regs) - { - aarch64_show_debug_reg_state (state, - "remove_hw_watchpoint", addr, len, type); - } - - return ret; -} - -/* Implement the "insert_watchpoint" target_ops method. - - Insert a watchpoint to watch a memory region which starts at - address ADDR and whose length is LEN bytes. Watch memory accesses - of the type TYPE. Return 0 on success, -1 on failure. */ - -int -aarch64_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len, - enum target_hw_bp_type type, - struct expression *cond) -{ - int ret; - struct aarch64_debug_reg_state *state - = aarch64_get_debug_reg_state (inferior_ptid.pid ()); - - if (show_debug_regs) - fprintf_unfiltered (gdb_stdlog, - "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n", - (unsigned long) addr, len); - - gdb_assert (type != hw_execute); - - ret = aarch64_handle_watchpoint (type, addr, len, 1 /* is_insert */, - inferior_ptid, state); - - if (show_debug_regs) - { - aarch64_show_debug_reg_state (state, - "insert_watchpoint", addr, len, type); - } - - return ret; -} - -/* Implement the "remove_watchpoint" target_ops method. - Remove a watchpoint that watched the memory region which starts at - address ADDR, whose length is LEN bytes, and for accesses of the - type TYPE. Return 0 on success, -1 on failure. */ - -int -aarch64_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len, - enum target_hw_bp_type type, - struct expression *cond) -{ - int ret; - struct aarch64_debug_reg_state *state - = aarch64_get_debug_reg_state (inferior_ptid.pid ()); - - if (show_debug_regs) - fprintf_unfiltered (gdb_stdlog, - "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n", - (unsigned long) addr, len); - - gdb_assert (type != hw_execute); - - ret = aarch64_handle_watchpoint (type, addr, len, 0 /* is_insert */, - inferior_ptid, state); - - if (show_debug_regs) - { - aarch64_show_debug_reg_state (state, - "remove_watchpoint", addr, len, type); - } - - return ret; -} - -/* Implement the "region_ok_for_hw_watchpoint" target_ops method. */ - -int -aarch64_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) -{ - return aarch64_region_ok_for_watchpoint (addr, len); -} - /* Implement the "stopped_data_address" target_ops method. */ bool aarch64_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p) { siginfo_t siginfo; - int i; struct aarch64_debug_reg_state *state; if (!linux_nat_get_siginfo (inferior_ptid, &siginfo)) @@ -980,44 +703,7 @@ aarch64_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p) /* Check if the address matches any watched address. */ state = aarch64_get_debug_reg_state (inferior_ptid.pid ()); - for (i = aarch64_num_wp_regs - 1; i >= 0; --i) - { - const unsigned int offset - = aarch64_watchpoint_offset (state->dr_ctrl_wp[i]); - const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]); - const CORE_ADDR addr_watch = state->dr_addr_wp[i] + offset; - const CORE_ADDR addr_watch_aligned = align_down (state->dr_addr_wp[i], 8); - const CORE_ADDR addr_orig = state->dr_addr_orig_wp[i]; - - if (state->dr_ref_count_wp[i] - && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i]) - && addr_trap >= addr_watch_aligned - && addr_trap < addr_watch + len) - { - /* ADDR_TRAP reports the first address of the memory range - accessed by the CPU, regardless of what was the memory - range watched. Thus, a large CPU access that straddles - the ADDR_WATCH..ADDR_WATCH+LEN range may result in an - ADDR_TRAP that is lower than the - ADDR_WATCH..ADDR_WATCH+LEN range. E.g.: - - addr: | 4 | 5 | 6 | 7 | 8 | - |---- range watched ----| - |----------- range accessed ------------| - - In this case, ADDR_TRAP will be 4. - - To match a watchpoint known to GDB core, we must never - report *ADDR_P outside of any ADDR_WATCH..ADDR_WATCH+LEN - range. ADDR_WATCH <= ADDR_TRAP < ADDR_ORIG is a false - positive on kernels older than 4.10. See PR - external/20207. */ - *addr_p = addr_orig; - return true; - } - } - - return false; + return aarch64_stopped_data_address (state, addr_trap, addr_p); } /* Implement the "stopped_by_watchpoint" target_ops method. */ @@ -1030,15 +716,6 @@ aarch64_linux_nat_target::stopped_by_watchpoint () return stopped_data_address (&addr); } -/* Implement the "watchpoint_addr_within_range" target_ops method. */ - -bool -aarch64_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr, - CORE_ADDR start, int length) -{ - return start <= addr && start + length - 1 >= addr; -} - /* Implement the "can_do_single_step" target_ops method. */ int @@ -1114,32 +791,11 @@ aarch64_linux_nat_target::store_memtags (CORE_ADDR address, size_t len, return false; } -/* Define AArch64 maintenance commands. */ - -static void -add_show_debug_regs_command (void) -{ - /* A maintenance command to enable printing the internal DRi mirror - variables. */ - add_setshow_boolean_cmd ("show-debug-regs", class_maintenance, - &show_debug_regs, _("\ -Set whether to show variables that mirror the AArch64 debug registers."), _("\ -Show whether to show variables that mirror the AArch64 debug registers."), _("\ -Use \"on\" to enable, \"off\" to disable.\n\ -If enabled, the debug registers values are shown when GDB inserts\n\ -or removes a hardware breakpoint or watchpoint, and when the inferior\n\ -triggers a breakpoint or watchpoint."), - NULL, - NULL, - &maintenance_set_cmdlist, - &maintenance_show_cmdlist); -} - void _initialize_aarch64_linux_nat (); void _initialize_aarch64_linux_nat () { - add_show_debug_regs_command (); + aarch64_initialize_hw_point (); /* Register the target. */ linux_target = &the_aarch64_linux_nat_target; diff --git a/gdb/aarch64-nat.c b/gdb/aarch64-nat.c new file mode 100644 index 0000000..85cf7f2 --- /dev/null +++ b/gdb/aarch64-nat.c @@ -0,0 +1,302 @@ +/* Native-dependent code for AArch64. + + Copyright (C) 2011-2022 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "defs.h" +#include "gdbarch.h" +#include "inferior.h" +#include "cli/cli-cmds.h" +#include "aarch64-nat.h" + +#include <unordered_map> + +/* Hash table storing per-process data. We don't bind this to a + per-inferior registry because of targets like x86 GNU/Linux that + need to keep track of processes that aren't bound to any inferior + (e.g., fork children, checkpoints). */ + +static std::unordered_map<pid_t, aarch64_debug_reg_state> +aarch64_debug_process_state; + +/* See aarch64-nat.h. */ + +struct aarch64_debug_reg_state * +aarch64_lookup_debug_reg_state (pid_t pid) +{ + auto it = aarch64_debug_process_state.find (pid); + if (it != aarch64_debug_process_state.end ()) + return &it->second; + + return nullptr; +} + +/* See aarch64-nat.h. */ + +struct aarch64_debug_reg_state * +aarch64_get_debug_reg_state (pid_t pid) +{ + return &aarch64_debug_process_state[pid]; +} + +/* See aarch64-nat.h. */ + +void +aarch64_remove_debug_reg_state (pid_t pid) +{ + aarch64_debug_process_state.erase (pid); +} + +/* Returns the number of hardware watchpoints of type TYPE that we can + set. Value is positive if we can set CNT watchpoints, zero if + setting watchpoints of type TYPE is not supported, and negative if + CNT is more than the maximum number of watchpoints of type TYPE + that we can support. TYPE is one of bp_hardware_watchpoint, + bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint. + CNT is the number of such watchpoints used so far (including this + one). OTHERTYPE is non-zero if other types of watchpoints are + currently enabled. */ + +int +aarch64_can_use_hw_breakpoint (enum bptype type, int cnt, int othertype) +{ + if (type == bp_hardware_watchpoint || type == bp_read_watchpoint + || type == bp_access_watchpoint || type == bp_watchpoint) + { + if (aarch64_num_wp_regs == 0) + return 0; + } + else if (type == bp_hardware_breakpoint) + { + if (aarch64_num_bp_regs == 0) + return 0; + } + else + gdb_assert_not_reached ("unexpected breakpoint type"); + + /* We always return 1 here because we don't have enough information + about possible overlap of addresses that they want to watch. As an + extreme example, consider the case where all the watchpoints watch + the same address and the same region length: then we can handle a + virtually unlimited number of watchpoints, due to debug register + sharing implemented via reference counts. */ + return 1; +} + +/* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address. + Return 0 on success, -1 on failure. */ + +int +aarch64_insert_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + int ret; + CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address; + int len; + const enum target_hw_bp_type type = hw_execute; + struct aarch64_debug_reg_state *state + = aarch64_get_debug_reg_state (inferior_ptid.pid ()); + + gdbarch_breakpoint_from_pc (gdbarch, &addr, &len); + + if (show_debug_regs) + fprintf_unfiltered + (gdb_stdlog, + "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n", + (unsigned long) addr, len); + + ret = aarch64_handle_breakpoint (type, addr, len, 1 /* is_insert */, + inferior_ptid, state); + + if (show_debug_regs) + { + aarch64_show_debug_reg_state (state, + "insert_hw_breakpoint", addr, len, type); + } + + return ret; +} + +/* Remove a hardware-assisted breakpoint at BP_TGT->placed_address. + Return 0 on success, -1 on failure. */ + +int +aarch64_remove_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + int ret; + CORE_ADDR addr = bp_tgt->placed_address; + int len = 4; + const enum target_hw_bp_type type = hw_execute; + struct aarch64_debug_reg_state *state + = aarch64_get_debug_reg_state (inferior_ptid.pid ()); + + gdbarch_breakpoint_from_pc (gdbarch, &addr, &len); + + if (show_debug_regs) + fprintf_unfiltered + (gdb_stdlog, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n", + (unsigned long) addr, len); + + ret = aarch64_handle_breakpoint (type, addr, len, 0 /* is_insert */, + inferior_ptid, state); + + if (show_debug_regs) + { + aarch64_show_debug_reg_state (state, + "remove_hw_watchpoint", addr, len, type); + } + + return ret; +} + +/* Insert a watchpoint to watch a memory region which starts at + address ADDR and whose length is LEN bytes. Watch memory accesses + of the type TYPE. Return 0 on success, -1 on failure. */ + +int +aarch64_insert_watchpoint (CORE_ADDR addr, int len, enum target_hw_bp_type type, + struct expression *cond) +{ + int ret; + struct aarch64_debug_reg_state *state + = aarch64_get_debug_reg_state (inferior_ptid.pid ()); + + if (show_debug_regs) + fprintf_unfiltered (gdb_stdlog, + "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n", + (unsigned long) addr, len); + + gdb_assert (type != hw_execute); + + ret = aarch64_handle_watchpoint (type, addr, len, 1 /* is_insert */, + inferior_ptid, state); + + if (show_debug_regs) + { + aarch64_show_debug_reg_state (state, + "insert_watchpoint", addr, len, type); + } + + return ret; +} + +/* Remove a watchpoint that watched the memory region which starts at + address ADDR, whose length is LEN bytes, and for accesses of the + type TYPE. Return 0 on success, -1 on failure. */ + +int +aarch64_remove_watchpoint (CORE_ADDR addr, int len, enum target_hw_bp_type type, + struct expression *cond) +{ + int ret; + struct aarch64_debug_reg_state *state + = aarch64_get_debug_reg_state (inferior_ptid.pid ()); + + if (show_debug_regs) + fprintf_unfiltered (gdb_stdlog, + "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n", + (unsigned long) addr, len); + + gdb_assert (type != hw_execute); + + ret = aarch64_handle_watchpoint (type, addr, len, 0 /* is_insert */, + inferior_ptid, state); + + if (show_debug_regs) + { + aarch64_show_debug_reg_state (state, + "remove_watchpoint", addr, len, type); + } + + return ret; +} + +/* See aarch64-nat.h. */ + +bool +aarch64_stopped_data_address (const struct aarch64_debug_reg_state *state, + CORE_ADDR addr_trap, CORE_ADDR *addr_p) +{ + int i; + + for (i = aarch64_num_wp_regs - 1; i >= 0; --i) + { + const unsigned int offset + = aarch64_watchpoint_offset (state->dr_ctrl_wp[i]); + const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]); + const CORE_ADDR addr_watch = state->dr_addr_wp[i] + offset; + const CORE_ADDR addr_watch_aligned = align_down (state->dr_addr_wp[i], 8); + const CORE_ADDR addr_orig = state->dr_addr_orig_wp[i]; + + if (state->dr_ref_count_wp[i] + && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i]) + && addr_trap >= addr_watch_aligned + && addr_trap < addr_watch + len) + { + /* ADDR_TRAP reports the first address of the memory range + accessed by the CPU, regardless of what was the memory + range watched. Thus, a large CPU access that straddles + the ADDR_WATCH..ADDR_WATCH+LEN range may result in an + ADDR_TRAP that is lower than the + ADDR_WATCH..ADDR_WATCH+LEN range. E.g.: + + addr: | 4 | 5 | 6 | 7 | 8 | + |---- range watched ----| + |----------- range accessed ------------| + + In this case, ADDR_TRAP will be 4. + + To match a watchpoint known to GDB core, we must never + report *ADDR_P outside of any ADDR_WATCH..ADDR_WATCH+LEN + range. ADDR_WATCH <= ADDR_TRAP < ADDR_ORIG is a false + positive on kernels older than 4.10. See PR + external/20207. */ + *addr_p = addr_orig; + return true; + } + } + + return false; +} + +/* Define AArch64 maintenance commands. */ + +static void +add_show_debug_regs_command (void) +{ + /* A maintenance command to enable printing the internal DRi mirror + variables. */ + add_setshow_boolean_cmd ("show-debug-regs", class_maintenance, + &show_debug_regs, _("\ +Set whether to show variables that mirror the AArch64 debug registers."), _("\ +Show whether to show variables that mirror the AArch64 debug registers."), _("\ +Use \"on\" to enable, \"off\" to disable.\n\ +If enabled, the debug registers values are shown when GDB inserts\n\ +or removes a hardware breakpoint or watchpoint, and when the inferior\n\ +triggers a breakpoint or watchpoint."), + NULL, + NULL, + &maintenance_set_cmdlist, + &maintenance_show_cmdlist); +} + +void +aarch64_initialize_hw_point () +{ + add_show_debug_regs_command (); +} diff --git a/gdb/aarch64-nat.h b/gdb/aarch64-nat.h new file mode 100644 index 0000000..56e720f --- /dev/null +++ b/gdb/aarch64-nat.h @@ -0,0 +1,109 @@ +/* Native-dependent code for AArch64. + + Copyright (C) 2011-2022 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#ifndef AARCH64_NAT_H +#define AARCH64_NAT_H + +#include "breakpoint.h" +#include "nat/aarch64-hw-point.h" +#include "target.h" + +/* Hardware-assisted breakpoints and watchpoints. */ + +/* Initialize platform-independent state for hardware-assisted + breakpoints and watchpoints. */ + +void aarch64_initialize_hw_point (); + +/* Return the debug register state for process PID. If no existing + state is found for this process, return nullptr. */ + +struct aarch64_debug_reg_state *aarch64_lookup_debug_reg_state (pid_t pid); + +/* Return the debug register state for process PID. If no existing + state is found for this process, create new state. */ + +struct aarch64_debug_reg_state *aarch64_get_debug_reg_state (pid_t pid); + +/* Remove any existing per-process debug state for process PID. */ + +void aarch64_remove_debug_reg_state (pid_t pid); + +/* Helper for the "stopped_data_address" target method. Returns TRUE + if a hardware watchpoint trap at ADDR_TRAP matches a set + watchpoint. The address of the matched watchpoint is returned in + *ADDR_P. */ + +bool aarch64_stopped_data_address (const struct aarch64_debug_reg_state *state, + CORE_ADDR addr_trap, CORE_ADDR *addr_p); + +/* Helper functions used by aarch64_nat_target below. See their + definitions. */ + +int aarch64_can_use_hw_breakpoint (enum bptype type, int cnt, int othertype); +int aarch64_insert_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond); +int aarch64_remove_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond); +int aarch64_insert_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt); +int aarch64_remove_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt); +int aarch64_stopped_by_hw_breakpoint (); + +/* Convenience template mixin used to add aarch64 watchpoints support to a + target. */ + +template <typename BaseTarget> +struct aarch64_nat_target : public BaseTarget +{ + /* Hook in common aarch64 hardware watchpoints/breakpoints support. */ + + int can_use_hw_breakpoint (enum bptype type, int cnt, int othertype) override + { return aarch64_can_use_hw_breakpoint (type, cnt, othertype); } + + int region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) override + { return aarch64_region_ok_for_watchpoint (addr, len); } + + int insert_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond) override + { return aarch64_insert_watchpoint (addr, len, type, cond); } + + int remove_watchpoint (CORE_ADDR addr, int len, + enum target_hw_bp_type type, + struct expression *cond) override + { return aarch64_remove_watchpoint (addr, len, type, cond); } + + int insert_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) override + { return aarch64_insert_hw_breakpoint (gdbarch, bp_tgt); } + + int remove_hw_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) override + { return aarch64_remove_hw_breakpoint (gdbarch, bp_tgt); } + + bool watchpoint_addr_within_range (CORE_ADDR addr, CORE_ADDR start, + int length) override + { return start <= addr && start + length - 1 >= addr; } +}; + +#endif /* AARCH64_NAT_H */ diff --git a/gdb/configure.nat b/gdb/configure.nat index ad6d35b..4f5850d 100644 --- a/gdb/configure.nat +++ b/gdb/configure.nat @@ -233,7 +233,7 @@ case ${gdb_host} in case ${gdb_host_cpu} in aarch64) # Host: AArch64 based machine running GNU/Linux - NATDEPFILES="${NATDEPFILES} aarch64-linux-nat.o \ + NATDEPFILES="${NATDEPFILES} aarch64-nat.o aarch64-linux-nat.o \ aarch32-linux-nat.o nat/aarch64-hw-point.o \ nat/aarch64-linux-hw-point.o \ nat/aarch64-linux.o \ |