gdb/aarch64-linux-nat.c

   1 /* Native-dependent code for GNU/Linux AArch64.
   2
   3    Copyright (C) 2011-2015 Free Software Foundation, Inc.
   4    Contributed by ARM Ltd.
   5
   6    This file is part of GDB.
   7
   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.
  12
  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.
  17
  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/>.  */
  20
  21 #include "defs.h"
  22
  23 #include "inferior.h"
  24 #include "gdbcore.h"
  25 #include "regcache.h"
  26 #include "linux-nat.h"
  27 #include "target-descriptions.h"
  28 #include "auxv.h"
  29 #include "gdbcmd.h"
  30 #include "aarch64-tdep.h"
  31 #include "aarch64-linux-tdep.h"
  32 #include "aarch32-linux-nat.h"
  33 #include "nat/aarch64-linux-hw-point.h"
  34
  35 #include "elf/external.h"
  36 #include "elf/common.h"
  37
  38 #include "nat/gdb_ptrace.h"
  39 #include <sys/utsname.h>
  40 #include <asm/ptrace.h>
  41
  42 #include "gregset.h"
  43
  44 /* Defines ps_err_e, struct ps_prochandle.  */
  45 #include "gdb_proc_service.h"
  46
  47 #ifndef TRAP_HWBKPT
  48 #define TRAP_HWBKPT 0x0004
  49 #endif
  50
  51 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
  52    case we may be tracing more than one process at a time.  In that
  53    case, inferior_ptid will contain the main process ID and the
  54    individual thread (process) ID.  get_thread_id () is used to get
  55    the thread id if it's available, and the process id otherwise.  */
  56
  57 static int
  58 get_thread_id (ptid_t ptid)
  59 {
  60   int tid = ptid_get_lwp (ptid);
  61
  62   if (0 == tid)
  63     tid = ptid_get_pid (ptid);
  64   return tid;
  65 }
  66
  67 /* Per-process data.  We don't bind this to a per-inferior registry
  68    because of targets like x86 GNU/Linux that need to keep track of
  69    processes that aren't bound to any inferior (e.g., fork children,
  70    checkpoints).  */
  71
  72 struct aarch64_process_info
  73 {
  74   /* Linked list.  */
  75   struct aarch64_process_info *next;
  76
  77   /* The process identifier.  */
  78   pid_t pid;
  79
  80   /* Copy of aarch64 hardware debug registers.  */
  81   struct aarch64_debug_reg_state state;
  82 };
  83
  84 static struct aarch64_process_info *aarch64_process_list = NULL;
  85
  86 /* Find process data for process PID.  */
  87
  88 static struct aarch64_process_info *
  89 aarch64_find_process_pid (pid_t pid)
  90 {
  91   struct aarch64_process_info *proc;
  92
  93   for (proc = aarch64_process_list; proc; proc = proc->next)
  94     if (proc->pid == pid)
  95       return proc;
  96
  97   return NULL;
  98 }
  99
 100 /* Add process data for process PID.  Returns newly allocated info
 101    object.  */
 102
 103 static struct aarch64_process_info *
 104 aarch64_add_process (pid_t pid)
 105 {
 106   struct aarch64_process_info *proc;
 107
 108   proc = xcalloc (1, sizeof (*proc));
 109   proc->pid = pid;
 110
 111   proc->next = aarch64_process_list;
 112   aarch64_process_list = proc;
 113
 114   return proc;
 115 }
 116
 117 /* Get data specific info for process PID, creating it if necessary.
 118    Never returns NULL.  */
 119
 120 static struct aarch64_process_info *
 121 aarch64_process_info_get (pid_t pid)
 122 {
 123   struct aarch64_process_info *proc;
 124
 125   proc = aarch64_find_process_pid (pid);
 126   if (proc == NULL)
 127     proc = aarch64_add_process (pid);
 128
 129   return proc;
 130 }
 131
 132 /* Called whenever GDB is no longer debugging process PID.  It deletes
 133    data structures that keep track of debug register state.  */
 134
 135 static void
 136 aarch64_forget_process (pid_t pid)
 137 {
 138   struct aarch64_process_info *proc, **proc_link;
 139
 140   proc = aarch64_process_list;
 141   proc_link = &aarch64_process_list;
 142
 143   while (proc != NULL)
 144     {
 145       if (proc->pid == pid)
 146         {
 147           *proc_link = proc->next;
 148
 149           xfree (proc);
 150           return;
 151         }
 152
 153       proc_link = &proc->next;
 154       proc = *proc_link;
 155     }
 156 }
 157
 158 /* Get debug registers state for process PID.  */
 159
 160 static struct aarch64_debug_reg_state *
 161 aarch64_get_debug_reg_state (pid_t pid)
 162 {
 163   return &aarch64_process_info_get (pid)->state;
 164 }
 165
 166 struct aarch64_dr_update_callback_param
 167 {
 168   int is_watchpoint;
 169   unsigned int idx;
 170 };
 171
 172 /* Callback for iterate_over_lwps.  Records the
 173    information about the change of one hardware breakpoint/watchpoint
 174    setting for the thread LWP.
 175    The information is passed in via PTR.
 176    N.B.  The actual updating of hardware debug registers is not
 177    carried out until the moment the thread is resumed.  */
 178
 179 static int
 180 debug_reg_change_callback (struct lwp_info *lwp, void *ptr)
 181 {
 182   struct aarch64_dr_update_callback_param *param_p
 183     = (struct aarch64_dr_update_callback_param *) ptr;
 184   int pid = get_thread_id (lwp->ptid);
 185   int idx = param_p->idx;
 186   int is_watchpoint = param_p->is_watchpoint;
 187   struct arch_lwp_info *info = lwp->arch_private;
 188   dr_changed_t *dr_changed_ptr;
 189   dr_changed_t dr_changed;
 190
 191   if (info == NULL)
 192     info = lwp->arch_private = XCNEW (struct arch_lwp_info);
 193
 194   if (show_debug_regs)
 195     {
 196       fprintf_unfiltered (gdb_stdlog,
 197                           "debug_reg_change_callback: \n\tOn entry:\n");
 198       fprintf_unfiltered (gdb_stdlog,
 199                           "\tpid%d, dr_changed_bp=0x%s, "
 200                           "dr_changed_wp=0x%s\n",
 201                           pid, phex (info->dr_changed_bp, 8),
 202                           phex (info->dr_changed_wp, 8));
 203     }
 204
 205   dr_changed_ptr = is_watchpoint ? &info->dr_changed_wp
 206     : &info->dr_changed_bp;
 207   dr_changed = *dr_changed_ptr;
 208
 209   gdb_assert (idx >= 0
 210               && (idx <= (is_watchpoint ? aarch64_num_wp_regs
 211                           : aarch64_num_bp_regs)));
 212
 213   /* The actual update is done later just before resuming the lwp,
 214      we just mark that one register pair needs updating.  */
 215   DR_MARK_N_CHANGED (dr_changed, idx);
 216   *dr_changed_ptr = dr_changed;
 217
 218   /* If the lwp isn't stopped, force it to momentarily pause, so
 219      we can update its debug registers.  */
 220   if (!lwp->stopped)
 221     linux_stop_lwp (lwp);
 222
 223   if (show_debug_regs)
 224     {
 225       fprintf_unfiltered (gdb_stdlog,
 226                           "\tOn exit:\n\tpid%d, dr_changed_bp=0x%s, "
 227                           "dr_changed_wp=0x%s\n",
 228                           pid, phex (info->dr_changed_bp, 8),
 229                           phex (info->dr_changed_wp, 8));
 230     }
 231
 232   /* Continue the iteration.  */
 233   return 0;
 234 }
 235
 236 /* Notify each thread that their IDXth breakpoint/watchpoint register
 237    pair needs to be updated.  The message will be recorded in each
 238    thread's arch-specific data area, the actual updating will be done
 239    when the thread is resumed.  */
 240
 241 void
 242 aarch64_notify_debug_reg_change (const struct aarch64_debug_reg_state *state,
 243                                  int is_watchpoint, unsigned int idx)
 244 {
 245   struct aarch64_dr_update_callback_param param;
 246   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
 247
 248   param.is_watchpoint = is_watchpoint;
 249   param.idx = idx;
 250
 251   iterate_over_lwps (pid_ptid, debug_reg_change_callback, (void *) &param);
 252 }
 253
 254 /* Fill GDB's register array with the general-purpose register values
 255    from the current thread.  */
 256
 257 static void
 258 fetch_gregs_from_thread (struct regcache *regcache)
 259 {
 260   int ret, tid;
 261   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 262   elf_gregset_t regs;
 263   struct iovec iovec;
 264
 265   /* Make sure REGS can hold all registers contents on both aarch64
 266      and arm.  */
 267   gdb_static_assert (sizeof (regs) >= 18 * 4);
 268
 269   tid = get_thread_id (inferior_ptid);
 270
 271   iovec.iov_base = &regs;
 272   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 273     iovec.iov_len = 18 * 4;
 274   else
 275     iovec.iov_len = sizeof (regs);
 276
 277   ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
 278   if (ret < 0)
 279     perror_with_name (_("Unable to fetch general registers."));
 280
 281   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 282     aarch32_gp_regcache_supply (regcache, (uint32_t *) regs, 1);
 283   else
 284     {
 285       int regno;
 286
 287       for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
 288         regcache_raw_supply (regcache, regno, &regs[regno - AARCH64_X0_REGNUM]);
 289     }
 290 }
 291
 292 /* Store to the current thread the valid general-purpose register
 293    values in the GDB's register array.  */
 294
 295 static void
 296 store_gregs_to_thread (const struct regcache *regcache)
 297 {
 298   int ret, tid;
 299   elf_gregset_t regs;
 300   struct iovec iovec;
 301   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 302
 303   /* Make sure REGS can hold all registers contents on both aarch64
 304      and arm.  */
 305   gdb_static_assert (sizeof (regs) >= 18 * 4);
 306   tid = get_thread_id (inferior_ptid);
 307
 308   iovec.iov_base = &regs;
 309   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 310     iovec.iov_len = 18 * 4;
 311   else
 312     iovec.iov_len = sizeof (regs);
 313
 314   ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
 315   if (ret < 0)
 316     perror_with_name (_("Unable to fetch general registers."));
 317
 318   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 319     aarch32_gp_regcache_collect (regcache, (uint32_t *) regs, 1);
 320   else
 321     {
 322       int regno;
 323
 324       for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
 325         if (REG_VALID == regcache_register_status (regcache, regno))
 326           regcache_raw_collect (regcache, regno,
 327                                 &regs[regno - AARCH64_X0_REGNUM]);
 328     }
 329
 330   ret = ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, &iovec);
 331   if (ret < 0)
 332     perror_with_name (_("Unable to store general registers."));
 333 }
 334
 335 /* Fill GDB's register array with the fp/simd register values
 336    from the current thread.  */
 337
 338 static void
 339 fetch_fpregs_from_thread (struct regcache *regcache)
 340 {
 341   int ret, tid;
 342   elf_fpregset_t regs;
 343   struct iovec iovec;
 344   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 345
 346   /* Make sure REGS can hold all VFP registers contents on both aarch64
 347      and arm.  */
 348   gdb_static_assert (sizeof regs >= VFP_REGS_SIZE);
 349
 350   tid = get_thread_id (inferior_ptid);
 351
 352   iovec.iov_base = &regs;
 353
 354   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 355     {
 356       iovec.iov_len = VFP_REGS_SIZE;
 357
 358       ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iovec);
 359       if (ret < 0)
 360         perror_with_name (_("Unable to fetch VFP registers."));
 361
 362       aarch32_vfp_regcache_supply (regcache, (gdb_byte *) &regs, 32);
 363     }
 364   else
 365     {
 366       int regno;
 367
 368       iovec.iov_len = sizeof (regs);
 369
 370       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iovec);
 371       if (ret < 0)
 372         perror_with_name (_("Unable to fetch vFP/SIMD registers."));
 373
 374       for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
 375         regcache_raw_supply (regcache, regno,
 376                              &regs.vregs[regno - AARCH64_V0_REGNUM]);
 377
 378       regcache_raw_supply (regcache, AARCH64_FPSR_REGNUM, &regs.fpsr);
 379       regcache_raw_supply (regcache, AARCH64_FPCR_REGNUM, &regs.fpcr);
 380     }
 381 }
 382
 383 /* Store to the current thread the valid fp/simd register
 384    values in the GDB's register array.  */
 385
 386 static void
 387 store_fpregs_to_thread (const struct regcache *regcache)
 388 {
 389   int ret, tid;
 390   elf_fpregset_t regs;
 391   struct iovec iovec;
 392   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 393
 394   /* Make sure REGS can hold all VFP registers contents on both aarch64
 395      and arm.  */
 396   gdb_static_assert (sizeof regs >= VFP_REGS_SIZE);
 397   tid = get_thread_id (inferior_ptid);
 398
 399   iovec.iov_base = &regs;
 400
 401   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 402     {
 403       iovec.iov_len = VFP_REGS_SIZE;
 404
 405       ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iovec);
 406       if (ret < 0)
 407         perror_with_name (_("Unable to fetch VFP registers."));
 408
 409       aarch32_vfp_regcache_collect (regcache, (gdb_byte *) &regs, 32);
 410     }
 411   else
 412     {
 413       int regno;
 414
 415       iovec.iov_len = sizeof (regs);
 416
 417       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iovec);
 418       if (ret < 0)
 419         perror_with_name (_("Unable to fetch FP/SIMD registers."));
 420
 421       for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
 422         if (REG_VALID == regcache_register_status (regcache, regno))
 423           regcache_raw_collect (regcache, regno,
 424                                 (char *) &regs.vregs[regno - AARCH64_V0_REGNUM]);
 425
 426       if (REG_VALID == regcache_register_status (regcache, AARCH64_FPSR_REGNUM))
 427         regcache_raw_collect (regcache, AARCH64_FPSR_REGNUM,
 428                               (char *) &regs.fpsr);
 429       if (REG_VALID == regcache_register_status (regcache, AARCH64_FPCR_REGNUM))
 430         regcache_raw_collect (regcache, AARCH64_FPCR_REGNUM,
 431                               (char *) &regs.fpcr);
 432     }
 433
 434   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 435     {
 436       ret = ptrace (PTRACE_SETREGSET, tid, NT_ARM_VFP, &iovec);
 437       if (ret < 0)
 438         perror_with_name (_("Unable to store VFP registers."));
 439     }
 440   else
 441     {
 442       ret = ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, &iovec);
 443       if (ret < 0)
 444         perror_with_name (_("Unable to store FP/SIMD registers."));
 445     }
 446 }
 447
 448 /* Implement the "to_fetch_register" target_ops method.  */
 449
 450 static void
 451 aarch64_linux_fetch_inferior_registers (struct target_ops *ops,
 452                                         struct regcache *regcache,
 453                                         int regno)
 454 {
 455   if (regno == -1)
 456     {
 457       fetch_gregs_from_thread (regcache);
 458       fetch_fpregs_from_thread (regcache);
 459     }
 460   else if (regno < AARCH64_V0_REGNUM)
 461     fetch_gregs_from_thread (regcache);
 462   else
 463     fetch_fpregs_from_thread (regcache);
 464 }
 465
 466 /* Implement the "to_store_register" target_ops method.  */
 467
 468 static void
 469 aarch64_linux_store_inferior_registers (struct target_ops *ops,
 470                                         struct regcache *regcache,
 471                                         int regno)
 472 {
 473   if (regno == -1)
 474     {
 475       store_gregs_to_thread (regcache);
 476       store_fpregs_to_thread (regcache);
 477     }
 478   else if (regno < AARCH64_V0_REGNUM)
 479     store_gregs_to_thread (regcache);
 480   else
 481     store_fpregs_to_thread (regcache);
 482 }
 483
 484 /* Fill register REGNO (if it is a general-purpose register) in
 485    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
 486    do this for all registers.  */
 487
 488 void
 489 fill_gregset (const struct regcache *regcache,
 490               gdb_gregset_t *gregsetp, int regno)
 491 {
 492   regcache_collect_regset (&aarch64_linux_gregset, regcache,
 493                            regno, (gdb_byte *) gregsetp,
 494                            AARCH64_LINUX_SIZEOF_GREGSET);
 495 }
 496
 497 /* Fill GDB's register array with the general-purpose register values
 498    in *GREGSETP.  */
 499
 500 void
 501 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
 502 {
 503   regcache_supply_regset (&aarch64_linux_gregset, regcache, -1,
 504                           (const gdb_byte *) gregsetp,
 505                           AARCH64_LINUX_SIZEOF_GREGSET);
 506 }
 507
 508 /* Fill register REGNO (if it is a floating-point register) in
 509    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 510    do this for all registers.  */
 511
 512 void
 513 fill_fpregset (const struct regcache *regcache,
 514                gdb_fpregset_t *fpregsetp, int regno)
 515 {
 516   regcache_collect_regset (&aarch64_linux_fpregset, regcache,
 517                            regno, (gdb_byte *) fpregsetp,
 518                            AARCH64_LINUX_SIZEOF_FPREGSET);
 519 }
 520
 521 /* Fill GDB's register array with the floating-point register values
 522    in *FPREGSETP.  */
 523
 524 void
 525 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
 526 {
 527   regcache_supply_regset (&aarch64_linux_fpregset, regcache, -1,
 528                           (const gdb_byte *) fpregsetp,
 529                           AARCH64_LINUX_SIZEOF_FPREGSET);
 530 }
 531
 532 /* Called when resuming a thread.
 533    The hardware debug registers are updated when there is any change.  */
 534
 535 static void
 536 aarch64_linux_prepare_to_resume (struct lwp_info *lwp)
 537 {
 538   struct arch_lwp_info *info = lwp->arch_private;
 539
 540   /* NULL means this is the main thread still going through the shell,
 541      or, no watchpoint has been set yet.  In that case, there's
 542      nothing to do.  */
 543   if (info == NULL)
 544     return;
 545
 546   if (DR_HAS_CHANGED (info->dr_changed_bp)
 547       || DR_HAS_CHANGED (info->dr_changed_wp))
 548     {
 549       int tid = ptid_get_lwp (lwp->ptid);
 550       struct aarch64_debug_reg_state *state
 551         = aarch64_get_debug_reg_state (ptid_get_pid (lwp->ptid));
 552
 553       if (show_debug_regs)
 554         fprintf_unfiltered (gdb_stdlog, "prepare_to_resume thread %d\n", tid);
 555
 556       /* Watchpoints.  */
 557       if (DR_HAS_CHANGED (info->dr_changed_wp))
 558         {
 559           aarch64_linux_set_debug_regs (state, tid, 1);
 560           DR_CLEAR_CHANGED (info->dr_changed_wp);
 561         }
 562
 563       /* Breakpoints.  */
 564       if (DR_HAS_CHANGED (info->dr_changed_bp))
 565         {
 566           aarch64_linux_set_debug_regs (state, tid, 0);
 567           DR_CLEAR_CHANGED (info->dr_changed_bp);
 568         }
 569     }
 570 }
 571
 572 static void
 573 aarch64_linux_new_thread (struct lwp_info *lp)
 574 {
 575   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
 576
 577   /* Mark that all the hardware breakpoint/watchpoint register pairs
 578      for this thread need to be initialized.  */
 579   DR_MARK_ALL_CHANGED (info->dr_changed_bp, aarch64_num_bp_regs);
 580   DR_MARK_ALL_CHANGED (info->dr_changed_wp, aarch64_num_wp_regs);
 581
 582   lp->arch_private = info;
 583 }
 584
 585 /* linux_nat_new_fork hook.   */
 586
 587 static void
 588 aarch64_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
 589 {
 590   pid_t parent_pid;
 591   struct aarch64_debug_reg_state *parent_state;
 592   struct aarch64_debug_reg_state *child_state;
 593
 594   /* NULL means no watchpoint has ever been set in the parent.  In
 595      that case, there's nothing to do.  */
 596   if (parent->arch_private == NULL)
 597     return;
 598
 599   /* GDB core assumes the child inherits the watchpoints/hw
 600      breakpoints of the parent, and will remove them all from the
 601      forked off process.  Copy the debug registers mirrors into the
 602      new process so that all breakpoints and watchpoints can be
 603      removed together.  */
 604
 605   parent_pid = ptid_get_pid (parent->ptid);
 606   parent_state = aarch64_get_debug_reg_state (parent_pid);
 607   child_state = aarch64_get_debug_reg_state (child_pid);
 608   *child_state = *parent_state;
 609 }
 610 \f
 611
 612 /* Called by libthread_db.  Returns a pointer to the thread local
 613    storage (or its descriptor).  */
 614
 615 ps_err_e
 616 ps_get_thread_area (const struct ps_prochandle *ph,
 617                     lwpid_t lwpid, int idx, void **base)
 618 {
 619   struct iovec iovec;
 620   uint64_t reg;
 621
 622   iovec.iov_base = &reg;
 623   iovec.iov_len = sizeof (reg);
 624
 625   if (ptrace (PTRACE_GETREGSET, lwpid, NT_ARM_TLS, &iovec) != 0)
 626     return PS_ERR;
 627
 628   /* IDX is the bias from the thread pointer to the beginning of the
 629      thread descriptor.  It has to be subtracted due to implementation
 630      quirks in libthread_db.  */
 631   *base = (void *) (reg - idx);
 632
 633   return PS_OK;
 634 }
 635 \f
 636
 637 static void (*super_post_startup_inferior) (struct target_ops *self,
 638                                             ptid_t ptid);
 639
 640 /* Implement the "to_post_startup_inferior" target_ops method.  */
 641
 642 static void
 643 aarch64_linux_child_post_startup_inferior (struct target_ops *self,
 644                                            ptid_t ptid)
 645 {
 646   aarch64_forget_process (ptid_get_pid (ptid));
 647   aarch64_linux_get_debug_reg_capacity (ptid_get_pid (ptid));
 648   super_post_startup_inferior (self, ptid);
 649 }
 650
 651 extern struct target_desc *tdesc_arm_with_vfpv3;
 652 extern struct target_desc *tdesc_arm_with_neon;
 653
 654 /* Implement the "to_read_description" target_ops method.  */
 655
 656 static const struct target_desc *
 657 aarch64_linux_read_description (struct target_ops *ops)
 658 {
 659   CORE_ADDR at_phent;
 660
 661   if (target_auxv_search (ops, AT_PHENT, &at_phent) == 1)
 662     {
 663       if (at_phent == sizeof (Elf64_External_Phdr))
 664         return tdesc_aarch64;
 665       else
 666         {
 667           CORE_ADDR arm_hwcap = 0;
 668
 669           if (target_auxv_search (ops, AT_HWCAP, &arm_hwcap) != 1)
 670             return ops->beneath->to_read_description (ops->beneath);
 671
 672 #ifndef COMPAT_HWCAP_VFP
 673 #define COMPAT_HWCAP_VFP        (1 << 6)
 674 #endif
 675 #ifndef COMPAT_HWCAP_NEON
 676 #define COMPAT_HWCAP_NEON       (1 << 12)
 677 #endif
 678 #ifndef COMPAT_HWCAP_VFPv3
 679 #define COMPAT_HWCAP_VFPv3      (1 << 13)
 680 #endif
 681
 682           if (arm_hwcap & COMPAT_HWCAP_VFP)
 683             {
 684               char *buf;
 685               const struct target_desc *result = NULL;
 686
 687               if (arm_hwcap & COMPAT_HWCAP_NEON)
 688                 result = tdesc_arm_with_neon;
 689               else if (arm_hwcap & COMPAT_HWCAP_VFPv3)
 690                 result = tdesc_arm_with_vfpv3;
 691
 692               return result;
 693             }
 694
 695           return NULL;
 696         }
 697     }
 698
 699   return tdesc_aarch64;
 700 }
 701
 702 /* Returns the number of hardware watchpoints of type TYPE that we can
 703    set.  Value is positive if we can set CNT watchpoints, zero if
 704    setting watchpoints of type TYPE is not supported, and negative if
 705    CNT is more than the maximum number of watchpoints of type TYPE
 706    that we can support.  TYPE is one of bp_hardware_watchpoint,
 707    bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
 708    CNT is the number of such watchpoints used so far (including this
 709    one).  OTHERTYPE is non-zero if other types of watchpoints are
 710    currently enabled.  */
 711
 712 static int
 713 aarch64_linux_can_use_hw_breakpoint (struct target_ops *self,
 714                                      enum bptype type,
 715                                      int cnt, int othertype)
 716 {
 717   if (type == bp_hardware_watchpoint || type == bp_read_watchpoint
 718       || type == bp_access_watchpoint || type == bp_watchpoint)
 719     {
 720       if (aarch64_num_wp_regs == 0)
 721         return 0;
 722     }
 723   else if (type == bp_hardware_breakpoint)
 724     {
 725       if (aarch64_num_bp_regs == 0)
 726         return 0;
 727     }
 728   else
 729     gdb_assert_not_reached ("unexpected breakpoint type");
 730
 731   /* We always return 1 here because we don't have enough information
 732      about possible overlap of addresses that they want to watch.  As an
 733      extreme example, consider the case where all the watchpoints watch
 734      the same address and the same region length: then we can handle a
 735      virtually unlimited number of watchpoints, due to debug register
 736      sharing implemented via reference counts.  */
 737   return 1;
 738 }
 739
 740 /* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address.
 741    Return 0 on success, -1 on failure.  */
 742
 743 static int
 744 aarch64_linux_insert_hw_breakpoint (struct target_ops *self,
 745                                     struct gdbarch *gdbarch,
 746                                     struct bp_target_info *bp_tgt)
 747 {
 748   int ret;
 749   CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
 750   const int len = 4;
 751   const enum target_hw_bp_type type = hw_execute;
 752   struct aarch64_debug_reg_state *state
 753     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 754
 755   if (show_debug_regs)
 756     fprintf_unfiltered
 757       (gdb_stdlog,
 758        "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
 759        (unsigned long) addr, len);
 760
 761   ret = aarch64_handle_breakpoint (type, addr, len, 1 /* is_insert */, state);
 762
 763   if (show_debug_regs)
 764     {
 765       aarch64_show_debug_reg_state (state,
 766                                     "insert_hw_breakpoint", addr, len, type);
 767     }
 768
 769   return ret;
 770 }
 771
 772 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
 773    Return 0 on success, -1 on failure.  */
 774
 775 static int
 776 aarch64_linux_remove_hw_breakpoint (struct target_ops *self,
 777                                     struct gdbarch *gdbarch,
 778                                     struct bp_target_info *bp_tgt)
 779 {
 780   int ret;
 781   CORE_ADDR addr = bp_tgt->placed_address;
 782   const int len = 4;
 783   const enum target_hw_bp_type type = hw_execute;
 784   struct aarch64_debug_reg_state *state
 785     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 786
 787   if (show_debug_regs)
 788     fprintf_unfiltered
 789       (gdb_stdlog, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
 790        (unsigned long) addr, len);
 791
 792   ret = aarch64_handle_breakpoint (type, addr, len, 0 /* is_insert */, state);
 793
 794   if (show_debug_regs)
 795     {
 796       aarch64_show_debug_reg_state (state,
 797                                     "remove_hw_watchpoint", addr, len, type);
 798     }
 799
 800   return ret;
 801 }
 802
 803 /* Implement the "to_insert_watchpoint" target_ops method.
 804
 805    Insert a watchpoint to watch a memory region which starts at
 806    address ADDR and whose length is LEN bytes.  Watch memory accesses
 807    of the type TYPE.  Return 0 on success, -1 on failure.  */
 808
 809 static int
 810 aarch64_linux_insert_watchpoint (struct target_ops *self,
 811                                  CORE_ADDR addr, int len,
 812                                  enum target_hw_bp_type type,
 813                                  struct expression *cond)
 814 {
 815   int ret;
 816   struct aarch64_debug_reg_state *state
 817     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 818
 819   if (show_debug_regs)
 820     fprintf_unfiltered (gdb_stdlog,
 821                         "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
 822                         (unsigned long) addr, len);
 823
 824   gdb_assert (type != hw_execute);
 825
 826   ret = aarch64_handle_watchpoint (type, addr, len, 1 /* is_insert */, state);
 827
 828   if (show_debug_regs)
 829     {
 830       aarch64_show_debug_reg_state (state,
 831                                     "insert_watchpoint", addr, len, type);
 832     }
 833
 834   return ret;
 835 }
 836
 837 /* Implement the "to_remove_watchpoint" target_ops method.
 838    Remove a watchpoint that watched the memory region which starts at
 839    address ADDR, whose length is LEN bytes, and for accesses of the
 840    type TYPE.  Return 0 on success, -1 on failure.  */
 841
 842 static int
 843 aarch64_linux_remove_watchpoint (struct target_ops *self,
 844                                  CORE_ADDR addr, int len,
 845                                  enum target_hw_bp_type type,
 846                                  struct expression *cond)
 847 {
 848   int ret;
 849   struct aarch64_debug_reg_state *state
 850     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 851
 852   if (show_debug_regs)
 853     fprintf_unfiltered (gdb_stdlog,
 854                         "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
 855                         (unsigned long) addr, len);
 856
 857   gdb_assert (type != hw_execute);
 858
 859   ret = aarch64_handle_watchpoint (type, addr, len, 0 /* is_insert */, state);
 860
 861   if (show_debug_regs)
 862     {
 863       aarch64_show_debug_reg_state (state,
 864                                     "remove_watchpoint", addr, len, type);
 865     }
 866
 867   return ret;
 868 }
 869
 870 /* Implement the "to_region_ok_for_hw_watchpoint" target_ops method.  */
 871
 872 static int
 873 aarch64_linux_region_ok_for_hw_watchpoint (struct target_ops *self,
 874                                            CORE_ADDR addr, int len)
 875 {
 876   CORE_ADDR aligned_addr;
 877
 878   /* Can not set watchpoints for zero or negative lengths.  */
 879   if (len <= 0)
 880     return 0;
 881
 882   /* Must have hardware watchpoint debug register(s).  */
 883   if (aarch64_num_wp_regs == 0)
 884     return 0;
 885
 886   /* We support unaligned watchpoint address and arbitrary length,
 887      as long as the size of the whole watched area after alignment
 888      doesn't exceed size of the total area that all watchpoint debug
 889      registers can watch cooperatively.
 890
 891      This is a very relaxed rule, but unfortunately there are
 892      limitations, e.g. false-positive hits, due to limited support of
 893      hardware debug registers in the kernel.  See comment above
 894      aarch64_align_watchpoint for more information.  */
 895
 896   aligned_addr = addr & ~(AARCH64_HWP_MAX_LEN_PER_REG - 1);
 897   if (aligned_addr + aarch64_num_wp_regs * AARCH64_HWP_MAX_LEN_PER_REG
 898       < addr + len)
 899     return 0;
 900
 901   /* All tests passed so we are likely to be able to set the watchpoint.
 902      The reason that it is 'likely' rather than 'must' is because
 903      we don't check the current usage of the watchpoint registers, and
 904      there may not be enough registers available for this watchpoint.
 905      Ideally we should check the cached debug register state, however
 906      the checking is costly.  */
 907   return 1;
 908 }
 909
 910 /* Implement the "to_stopped_data_address" target_ops method.  */
 911
 912 static int
 913 aarch64_linux_stopped_data_address (struct target_ops *target,
 914                                     CORE_ADDR *addr_p)
 915 {
 916   siginfo_t siginfo;
 917   int i, tid;
 918   struct aarch64_debug_reg_state *state;
 919
 920   if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
 921     return 0;
 922
 923   /* This must be a hardware breakpoint.  */
 924   if (siginfo.si_signo != SIGTRAP
 925       || (siginfo.si_code & 0xffff) != TRAP_HWBKPT)
 926     return 0;
 927
 928   /* Check if the address matches any watched address.  */
 929   state = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 930   for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
 931     {
 932       const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
 933       const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
 934       const CORE_ADDR addr_watch = state->dr_addr_wp[i];
 935
 936       if (state->dr_ref_count_wp[i]
 937           && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
 938           && addr_trap >= addr_watch
 939           && addr_trap < addr_watch + len)
 940         {
 941           *addr_p = addr_trap;
 942           return 1;
 943         }
 944     }
 945
 946   return 0;
 947 }
 948
 949 /* Implement the "to_stopped_by_watchpoint" target_ops method.  */
 950
 951 static int
 952 aarch64_linux_stopped_by_watchpoint (struct target_ops *ops)
 953 {
 954   CORE_ADDR addr;
 955
 956   return aarch64_linux_stopped_data_address (ops, &addr);
 957 }
 958
 959 /* Implement the "to_watchpoint_addr_within_range" target_ops method.  */
 960
 961 static int
 962 aarch64_linux_watchpoint_addr_within_range (struct target_ops *target,
 963                                             CORE_ADDR addr,
 964                                             CORE_ADDR start, int length)
 965 {
 966   return start <= addr && start + length - 1 >= addr;
 967 }
 968
 969 /* Define AArch64 maintenance commands.  */
 970
 971 static void
 972 add_show_debug_regs_command (void)
 973 {
 974   /* A maintenance command to enable printing the internal DRi mirror
 975      variables.  */
 976   add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
 977                            &show_debug_regs, _("\
 978 Set whether to show variables that mirror the AArch64 debug registers."), _("\
 979 Show whether to show variables that mirror the AArch64 debug registers."), _("\
 980 Use \"on\" to enable, \"off\" to disable.\n\
 981 If enabled, the debug registers values are shown when GDB inserts\n\
 982 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
 983 triggers a breakpoint or watchpoint."),
 984                            NULL,
 985                            NULL,
 986                            &maintenance_set_cmdlist,
 987                            &maintenance_show_cmdlist);
 988 }
 989
 990 /* -Wmissing-prototypes.  */
 991 void _initialize_aarch64_linux_nat (void);
 992
 993 void
 994 _initialize_aarch64_linux_nat (void)
 995 {
 996   struct target_ops *t;
 997
 998   /* Fill in the generic GNU/Linux methods.  */
 999   t = linux_target ();
1000
1001   add_show_debug_regs_command ();
1002
1003   /* Add our register access methods.  */
1004   t->to_fetch_registers = aarch64_linux_fetch_inferior_registers;
1005   t->to_store_registers = aarch64_linux_store_inferior_registers;
1006
1007   t->to_read_description = aarch64_linux_read_description;
1008
1009   t->to_can_use_hw_breakpoint = aarch64_linux_can_use_hw_breakpoint;
1010   t->to_insert_hw_breakpoint = aarch64_linux_insert_hw_breakpoint;
1011   t->to_remove_hw_breakpoint = aarch64_linux_remove_hw_breakpoint;
1012   t->to_region_ok_for_hw_watchpoint =
1013     aarch64_linux_region_ok_for_hw_watchpoint;
1014   t->to_insert_watchpoint = aarch64_linux_insert_watchpoint;
1015   t->to_remove_watchpoint = aarch64_linux_remove_watchpoint;
1016   t->to_stopped_by_watchpoint = aarch64_linux_stopped_by_watchpoint;
1017   t->to_stopped_data_address = aarch64_linux_stopped_data_address;
1018   t->to_watchpoint_addr_within_range =
1019     aarch64_linux_watchpoint_addr_within_range;
1020
1021   /* Override the GNU/Linux inferior startup hook.  */
1022   super_post_startup_inferior = t->to_post_startup_inferior;
1023   t->to_post_startup_inferior = aarch64_linux_child_post_startup_inferior;
1024
1025   /* Register the target.  */
1026   linux_nat_add_target (t);
1027   linux_nat_set_new_thread (t, aarch64_linux_new_thread);
1028   linux_nat_set_new_fork (t, aarch64_linux_new_fork);
1029   linux_nat_set_forget_process (t, aarch64_forget_process);
1030   linux_nat_set_prepare_to_resume (t, aarch64_linux_prepare_to_resume);
1031 }