gdb/aarch64-fbsd-nat.c

   1 /* Native-dependent code for FreeBSD/aarch64.
   2
   3    Copyright (C) 2017-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "inferior.h"
  23 #include "regcache.h"
  24 #include "target.h"
  25 #include "nat/aarch64-hw-point.h"
  26
  27 #include "elf/common.h"
  28
  29 #include <sys/param.h>
  30 #include <sys/ptrace.h>
  31 #include <machine/armreg.h>
  32 #include <machine/reg.h>
  33
  34 #include "fbsd-nat.h"
  35 #include "aarch64-tdep.h"
  36 #include "aarch64-fbsd-tdep.h"
  37 #include "aarch64-nat.h"
  38 #include "inf-ptrace.h"
  39
  40 #if __FreeBSD_version >= 1400005
  41 #define HAVE_DBREG
  42
  43 #include <unordered_set>
  44 #endif
  45
  46 #ifdef HAVE_DBREG
  47 struct aarch64_fbsd_nat_target final
  48   : public aarch64_nat_target<fbsd_nat_target>
  49 #else
  50 struct aarch64_fbsd_nat_target final : public fbsd_nat_target
  51 #endif
  52 {
  53   void fetch_registers (struct regcache *, int) override;
  54   void store_registers (struct regcache *, int) override;
  55
  56   const struct target_desc *read_description () override;
  57
  58 #ifdef HAVE_DBREG
  59   /* Hardware breakpoints and watchpoints.  */
  60   bool stopped_by_watchpoint () override;
  61   bool stopped_data_address (CORE_ADDR *) override;
  62   bool stopped_by_hw_breakpoint () override;
  63   bool supports_stopped_by_hw_breakpoint () override;
  64
  65   void post_startup_inferior (ptid_t) override;
  66   void post_attach (int pid) override;
  67
  68   void low_new_fork (ptid_t parent, pid_t child) override;
  69   void low_delete_thread (thread_info *) override;
  70   void low_prepare_to_resume (thread_info *) override;
  71
  72 private:
  73   void probe_debug_regs (int pid);
  74   static bool debug_regs_probed;
  75 #endif
  76 };
  77
  78 static aarch64_fbsd_nat_target the_aarch64_fbsd_nat_target;
  79
  80 /* Fetch register REGNUM from the inferior.  If REGNUM is -1, do this
  81    for all registers.  */
  82
  83 void
  84 aarch64_fbsd_nat_target::fetch_registers (struct regcache *regcache,
  85                                           int regnum)
  86 {
  87   fetch_register_set<struct reg> (regcache, regnum, PT_GETREGS,
  88                                   &aarch64_fbsd_gregset);
  89   fetch_register_set<struct fpreg> (regcache, regnum, PT_GETFPREGS,
  90                                     &aarch64_fbsd_fpregset);
  91
  92   gdbarch *gdbarch = regcache->arch ();
  93   aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
  94   if (tdep->has_tls ())
  95     fetch_regset<uint64_t> (regcache, regnum, NT_ARM_TLS,
  96                             &aarch64_fbsd_tls_regset, tdep->tls_regnum_base);
  97 }
  98
  99 /* Store register REGNUM back into the inferior.  If REGNUM is -1, do
 100    this for all registers.  */
 101
 102 void
 103 aarch64_fbsd_nat_target::store_registers (struct regcache *regcache,
 104                                           int regnum)
 105 {
 106   store_register_set<struct reg> (regcache, regnum, PT_GETREGS, PT_SETREGS,
 107                                   &aarch64_fbsd_gregset);
 108   store_register_set<struct fpreg> (regcache, regnum, PT_GETFPREGS,
 109                                     PT_SETFPREGS, &aarch64_fbsd_fpregset);
 110
 111   gdbarch *gdbarch = regcache->arch ();
 112   aarch64_gdbarch_tdep *tdep = gdbarch_tdep<aarch64_gdbarch_tdep> (gdbarch);
 113   if (tdep->has_tls ())
 114     store_regset<uint64_t> (regcache, regnum, NT_ARM_TLS,
 115                             &aarch64_fbsd_tls_regset, tdep->tls_regnum_base);
 116 }
 117
 118 /* Implement the target read_description method.  */
 119
 120 const struct target_desc *
 121 aarch64_fbsd_nat_target::read_description ()
 122 {
 123   if (inferior_ptid == null_ptid)
 124     return this->beneath ()->read_description ();
 125
 126   aarch64_features features;
 127   features.tls = have_regset (inferior_ptid, NT_ARM_TLS)? 1 : 0;
 128   return aarch64_read_description (features);
 129 }
 130
 131 #ifdef HAVE_DBREG
 132 bool aarch64_fbsd_nat_target::debug_regs_probed;
 133
 134 /* Set of threads which need to update debug registers on next resume.  */
 135
 136 static std::unordered_set<lwpid_t> aarch64_debug_pending_threads;
 137
 138 /* Implement the "stopped_data_address" target_ops method.  */
 139
 140 bool
 141 aarch64_fbsd_nat_target::stopped_data_address (CORE_ADDR *addr_p)
 142 {
 143   siginfo_t siginfo;
 144   struct aarch64_debug_reg_state *state;
 145
 146   if (!fbsd_nat_get_siginfo (inferior_ptid, &siginfo))
 147     return false;
 148
 149   /* This must be a hardware breakpoint.  */
 150   if (siginfo.si_signo != SIGTRAP
 151       || siginfo.si_code != TRAP_TRACE
 152       || siginfo.si_trapno != EXCP_WATCHPT_EL0)
 153     return false;
 154
 155   const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
 156
 157   /* Check if the address matches any watched address.  */
 158   state = aarch64_get_debug_reg_state (inferior_ptid.pid ());
 159   return aarch64_stopped_data_address (state, addr_trap, addr_p);
 160 }
 161
 162 /* Implement the "stopped_by_watchpoint" target_ops method.  */
 163
 164 bool
 165 aarch64_fbsd_nat_target::stopped_by_watchpoint ()
 166 {
 167   return stopped_data_address (nullptr);
 168 }
 169
 170 /* Implement the "stopped_by_hw_breakpoint" target_ops method.  */
 171
 172 bool
 173 aarch64_fbsd_nat_target::stopped_by_hw_breakpoint ()
 174 {
 175   siginfo_t siginfo;
 176   struct aarch64_debug_reg_state *state;
 177
 178   if (!fbsd_nat_get_siginfo (inferior_ptid, &siginfo))
 179     return false;
 180
 181   /* This must be a hardware breakpoint.  */
 182   if (siginfo.si_signo != SIGTRAP
 183       || siginfo.si_code != TRAP_TRACE
 184       || siginfo.si_trapno != EXCP_WATCHPT_EL0)
 185     return false;
 186
 187   return !stopped_by_watchpoint();
 188 }
 189
 190 /* Implement the "supports_stopped_by_hw_breakpoint" target_ops method.  */
 191
 192 bool
 193 aarch64_fbsd_nat_target::supports_stopped_by_hw_breakpoint ()
 194 {
 195   return true;
 196 }
 197
 198 /* Fetch the hardware debug register capability information.  */
 199
 200 void
 201 aarch64_fbsd_nat_target::probe_debug_regs (int pid)
 202 {
 203   if (!debug_regs_probed)
 204     {
 205       struct dbreg reg;
 206
 207       debug_regs_probed = true;
 208       aarch64_num_bp_regs = 0;
 209       aarch64_num_wp_regs = 0;
 210
 211       if (ptrace(PT_GETDBREGS, pid, (PTRACE_TYPE_ARG3) &reg, 0) == 0)
 212         {
 213           switch (reg.db_debug_ver)
 214             {
 215             case AARCH64_DEBUG_ARCH_V8:
 216             case AARCH64_DEBUG_ARCH_V8_1:
 217             case AARCH64_DEBUG_ARCH_V8_2:
 218             case AARCH64_DEBUG_ARCH_V8_4:
 219             case AARCH64_DEBUG_ARCH_V8_8:
 220             case AARCH64_DEBUG_ARCH_V8_9:
 221               break;
 222             default:
 223               return;
 224             }
 225
 226           aarch64_num_bp_regs = reg.db_nbkpts;
 227           if (aarch64_num_bp_regs > AARCH64_HBP_MAX_NUM)
 228             {
 229               warning (_("Unexpected number of hardware breakpoint registers"
 230                          " reported by ptrace, got %d, expected %d."),
 231                        aarch64_num_bp_regs, AARCH64_HBP_MAX_NUM);
 232               aarch64_num_bp_regs = AARCH64_HBP_MAX_NUM;
 233             }
 234           aarch64_num_wp_regs = reg.db_nwtpts;
 235           if (aarch64_num_wp_regs > AARCH64_HWP_MAX_NUM)
 236             {
 237               warning (_("Unexpected number of hardware watchpoint registers"
 238                          " reported by ptrace, got %d, expected %d."),
 239                        aarch64_num_wp_regs, AARCH64_HWP_MAX_NUM);
 240               aarch64_num_wp_regs = AARCH64_HWP_MAX_NUM;
 241             }
 242         }
 243     }
 244 }
 245
 246 /* Implement the virtual inf_ptrace_target::post_startup_inferior method.  */
 247
 248 void
 249 aarch64_fbsd_nat_target::post_startup_inferior (ptid_t ptid)
 250 {
 251   aarch64_remove_debug_reg_state (ptid.pid ());
 252   probe_debug_regs (ptid.pid ());
 253   fbsd_nat_target::post_startup_inferior (ptid);
 254 }
 255
 256 /* Implement the "post_attach" target_ops method.  */
 257
 258 void
 259 aarch64_fbsd_nat_target::post_attach (int pid)
 260 {
 261   aarch64_remove_debug_reg_state (pid);
 262   probe_debug_regs (pid);
 263   fbsd_nat_target::post_attach (pid);
 264 }
 265
 266 /* Implement the virtual fbsd_nat_target::low_new_fork method.  */
 267
 268 void
 269 aarch64_fbsd_nat_target::low_new_fork (ptid_t parent, pid_t child)
 270 {
 271   struct aarch64_debug_reg_state *parent_state, *child_state;
 272
 273   /* If there is no parent state, no watchpoints nor breakpoints have
 274      been set, so there is nothing to do.  */
 275   parent_state = aarch64_lookup_debug_reg_state (parent.pid ());
 276   if (parent_state == nullptr)
 277     return;
 278
 279   /* The kernel clears debug registers in the new child process after
 280      fork, but GDB core assumes the child inherits the watchpoints/hw
 281      breakpoints of the parent, and will remove them all from the
 282      forked off process.  Copy the debug registers mirrors into the
 283      new process so that all breakpoints and watchpoints can be
 284      removed together.  */
 285
 286   child_state = aarch64_get_debug_reg_state (child);
 287   *child_state = *parent_state;
 288 }
 289
 290 /* Mark debug register state "dirty" for all threads belonging to the
 291    current inferior.  */
 292
 293 void
 294 aarch64_notify_debug_reg_change (ptid_t ptid,
 295                                  int is_watchpoint, unsigned int idx)
 296 {
 297   for (thread_info *tp : current_inferior ()->non_exited_threads ())
 298     {
 299       if (tp->ptid.lwp_p ())
 300         aarch64_debug_pending_threads.emplace (tp->ptid.lwp ());
 301     }
 302 }
 303
 304 /* Implement the virtual fbsd_nat_target::low_delete_thread method.  */
 305
 306 void
 307 aarch64_fbsd_nat_target::low_delete_thread (thread_info *tp)
 308 {
 309   gdb_assert(tp->ptid.lwp_p ());
 310   aarch64_debug_pending_threads.erase (tp->ptid.lwp ());
 311 }
 312
 313 /* Implement the virtual fbsd_nat_target::low_prepare_to_resume method.  */
 314
 315 void
 316 aarch64_fbsd_nat_target::low_prepare_to_resume (thread_info *tp)
 317 {
 318   gdb_assert(tp->ptid.lwp_p ());
 319
 320   if (aarch64_debug_pending_threads.erase (tp->ptid.lwp ()) == 0)
 321     return;
 322
 323   struct aarch64_debug_reg_state *state =
 324     aarch64_lookup_debug_reg_state (tp->ptid.pid ());
 325   gdb_assert(state != nullptr);
 326
 327   struct dbreg reg;
 328   memset (&reg, 0, sizeof(reg));
 329   for (int i = 0; i < aarch64_num_bp_regs; i++)
 330     {
 331       reg.db_breakregs[i].dbr_addr = state->dr_addr_bp[i];
 332       reg.db_breakregs[i].dbr_ctrl = state->dr_ctrl_bp[i];
 333     }
 334   for (int i = 0; i < aarch64_num_wp_regs; i++)
 335     {
 336       reg.db_watchregs[i].dbw_addr = state->dr_addr_wp[i];
 337       reg.db_watchregs[i].dbw_ctrl = state->dr_ctrl_wp[i];
 338     }
 339   if (ptrace(PT_SETDBREGS, tp->ptid.lwp (), (PTRACE_TYPE_ARG3) &reg, 0) != 0)
 340     error (_("Failed to set hardware debug registers"));
 341 }
 342 #else
 343 /* A stub that should never be called.  */
 344 void
 345 aarch64_notify_debug_reg_change (ptid_t ptid,
 346                                  int is_watchpoint, unsigned int idx)
 347 {
 348   gdb_assert (true);
 349 }
 350 #endif
 351
 352 void _initialize_aarch64_fbsd_nat ();
 353 void
 354 _initialize_aarch64_fbsd_nat ()
 355 {
 356 #ifdef HAVE_DBREG
 357   aarch64_initialize_hw_point ();
 358 #endif
 359   add_inf_child_target (&the_aarch64_fbsd_nat_target);
 360 }