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 <sys/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    We always return 1 here because we don't have enough information
 713    about possible overlap of addresses that they want to watch.  As an
 714    extreme example, consider the case where all the watchpoints watch
 715    the same address and the same region length: then we can handle a
 716    virtually unlimited number of watchpoints, due to debug register
 717    sharing implemented via reference counts.  */
 718
 719 static int
 720 aarch64_linux_can_use_hw_breakpoint (struct target_ops *self,
 721                                      int type, int cnt, int othertype)
 722 {
 723   return 1;
 724 }
 725
 726 /* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address.
 727    Return 0 on success, -1 on failure.  */
 728
 729 static int
 730 aarch64_linux_insert_hw_breakpoint (struct target_ops *self,
 731                                     struct gdbarch *gdbarch,
 732                                     struct bp_target_info *bp_tgt)
 733 {
 734   int ret;
 735   CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
 736   const int len = 4;
 737   const enum target_hw_bp_type type = hw_execute;
 738   struct aarch64_debug_reg_state *state
 739     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 740
 741   if (show_debug_regs)
 742     fprintf_unfiltered
 743       (gdb_stdlog,
 744        "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
 745        (unsigned long) addr, len);
 746
 747   ret = aarch64_handle_breakpoint (type, addr, len, 1 /* is_insert */, state);
 748
 749   if (show_debug_regs)
 750     {
 751       aarch64_show_debug_reg_state (state,
 752                                     "insert_hw_breakpoint", addr, len, type);
 753     }
 754
 755   return ret;
 756 }
 757
 758 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
 759    Return 0 on success, -1 on failure.  */
 760
 761 static int
 762 aarch64_linux_remove_hw_breakpoint (struct target_ops *self,
 763                                     struct gdbarch *gdbarch,
 764                                     struct bp_target_info *bp_tgt)
 765 {
 766   int ret;
 767   CORE_ADDR addr = bp_tgt->placed_address;
 768   const int len = 4;
 769   const enum target_hw_bp_type type = hw_execute;
 770   struct aarch64_debug_reg_state *state
 771     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 772
 773   if (show_debug_regs)
 774     fprintf_unfiltered
 775       (gdb_stdlog, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
 776        (unsigned long) addr, len);
 777
 778   ret = aarch64_handle_breakpoint (type, addr, len, 0 /* is_insert */, state);
 779
 780   if (show_debug_regs)
 781     {
 782       aarch64_show_debug_reg_state (state,
 783                                     "remove_hw_watchpoint", addr, len, type);
 784     }
 785
 786   return ret;
 787 }
 788
 789 /* Implement the "to_insert_watchpoint" target_ops method.
 790
 791    Insert a watchpoint to watch a memory region which starts at
 792    address ADDR and whose length is LEN bytes.  Watch memory accesses
 793    of the type TYPE.  Return 0 on success, -1 on failure.  */
 794
 795 static int
 796 aarch64_linux_insert_watchpoint (struct target_ops *self,
 797                                  CORE_ADDR addr, int len, int type,
 798                                  struct expression *cond)
 799 {
 800   int ret;
 801   struct aarch64_debug_reg_state *state
 802     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 803
 804   if (show_debug_regs)
 805     fprintf_unfiltered (gdb_stdlog,
 806                         "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
 807                         (unsigned long) addr, len);
 808
 809   gdb_assert (type != hw_execute);
 810
 811   ret = aarch64_handle_watchpoint (type, addr, len, 1 /* is_insert */, state);
 812
 813   if (show_debug_regs)
 814     {
 815       aarch64_show_debug_reg_state (state,
 816                                     "insert_watchpoint", addr, len, type);
 817     }
 818
 819   return ret;
 820 }
 821
 822 /* Implement the "to_remove_watchpoint" target_ops method.
 823    Remove a watchpoint that watched the memory region which starts at
 824    address ADDR, whose length is LEN bytes, and for accesses of the
 825    type TYPE.  Return 0 on success, -1 on failure.  */
 826
 827 static int
 828 aarch64_linux_remove_watchpoint (struct target_ops *self,
 829                                  CORE_ADDR addr, int len, int type,
 830                                  struct expression *cond)
 831 {
 832   int ret;
 833   struct aarch64_debug_reg_state *state
 834     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 835
 836   if (show_debug_regs)
 837     fprintf_unfiltered (gdb_stdlog,
 838                         "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
 839                         (unsigned long) addr, len);
 840
 841   gdb_assert (type != hw_execute);
 842
 843   ret = aarch64_handle_watchpoint (type, addr, len, 0 /* is_insert */, state);
 844
 845   if (show_debug_regs)
 846     {
 847       aarch64_show_debug_reg_state (state,
 848                                     "remove_watchpoint", addr, len, type);
 849     }
 850
 851   return ret;
 852 }
 853
 854 /* Implement the "to_region_ok_for_hw_watchpoint" target_ops method.  */
 855
 856 static int
 857 aarch64_linux_region_ok_for_hw_watchpoint (struct target_ops *self,
 858                                            CORE_ADDR addr, int len)
 859 {
 860   CORE_ADDR aligned_addr;
 861
 862   /* Can not set watchpoints for zero or negative lengths.  */
 863   if (len <= 0)
 864     return 0;
 865
 866   /* Must have hardware watchpoint debug register(s).  */
 867   if (aarch64_num_wp_regs == 0)
 868     return 0;
 869
 870   /* We support unaligned watchpoint address and arbitrary length,
 871      as long as the size of the whole watched area after alignment
 872      doesn't exceed size of the total area that all watchpoint debug
 873      registers can watch cooperatively.
 874
 875      This is a very relaxed rule, but unfortunately there are
 876      limitations, e.g. false-positive hits, due to limited support of
 877      hardware debug registers in the kernel.  See comment above
 878      aarch64_align_watchpoint for more information.  */
 879
 880   aligned_addr = addr & ~(AARCH64_HWP_MAX_LEN_PER_REG - 1);
 881   if (aligned_addr + aarch64_num_wp_regs * AARCH64_HWP_MAX_LEN_PER_REG
 882       < addr + len)
 883     return 0;
 884
 885   /* All tests passed so we are likely to be able to set the watchpoint.
 886      The reason that it is 'likely' rather than 'must' is because
 887      we don't check the current usage of the watchpoint registers, and
 888      there may not be enough registers available for this watchpoint.
 889      Ideally we should check the cached debug register state, however
 890      the checking is costly.  */
 891   return 1;
 892 }
 893
 894 /* Implement the "to_stopped_data_address" target_ops method.  */
 895
 896 static int
 897 aarch64_linux_stopped_data_address (struct target_ops *target,
 898                                     CORE_ADDR *addr_p)
 899 {
 900   siginfo_t siginfo;
 901   int i, tid;
 902   struct aarch64_debug_reg_state *state;
 903
 904   if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
 905     return 0;
 906
 907   /* This must be a hardware breakpoint.  */
 908   if (siginfo.si_signo != SIGTRAP
 909       || (siginfo.si_code & 0xffff) != TRAP_HWBKPT)
 910     return 0;
 911
 912   /* Check if the address matches any watched address.  */
 913   state = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
 914   for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
 915     {
 916       const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
 917       const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
 918       const CORE_ADDR addr_watch = state->dr_addr_wp[i];
 919
 920       if (state->dr_ref_count_wp[i]
 921           && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
 922           && addr_trap >= addr_watch
 923           && addr_trap < addr_watch + len)
 924         {
 925           *addr_p = addr_trap;
 926           return 1;
 927         }
 928     }
 929
 930   return 0;
 931 }
 932
 933 /* Implement the "to_stopped_by_watchpoint" target_ops method.  */
 934
 935 static int
 936 aarch64_linux_stopped_by_watchpoint (struct target_ops *ops)
 937 {
 938   CORE_ADDR addr;
 939
 940   return aarch64_linux_stopped_data_address (ops, &addr);
 941 }
 942
 943 /* Implement the "to_watchpoint_addr_within_range" target_ops method.  */
 944
 945 static int
 946 aarch64_linux_watchpoint_addr_within_range (struct target_ops *target,
 947                                             CORE_ADDR addr,
 948                                             CORE_ADDR start, int length)
 949 {
 950   return start <= addr && start + length - 1 >= addr;
 951 }
 952
 953 /* Define AArch64 maintenance commands.  */
 954
 955 static void
 956 add_show_debug_regs_command (void)
 957 {
 958   /* A maintenance command to enable printing the internal DRi mirror
 959      variables.  */
 960   add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
 961                            &show_debug_regs, _("\
 962 Set whether to show variables that mirror the AArch64 debug registers."), _("\
 963 Show whether to show variables that mirror the AArch64 debug registers."), _("\
 964 Use \"on\" to enable, \"off\" to disable.\n\
 965 If enabled, the debug registers values are shown when GDB inserts\n\
 966 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
 967 triggers a breakpoint or watchpoint."),
 968                            NULL,
 969                            NULL,
 970                            &maintenance_set_cmdlist,
 971                            &maintenance_show_cmdlist);
 972 }
 973
 974 /* -Wmissing-prototypes.  */
 975 void _initialize_aarch64_linux_nat (void);
 976
 977 void
 978 _initialize_aarch64_linux_nat (void)
 979 {
 980   struct target_ops *t;
 981
 982   /* Fill in the generic GNU/Linux methods.  */
 983   t = linux_target ();
 984
 985   add_show_debug_regs_command ();
 986
 987   /* Add our register access methods.  */
 988   t->to_fetch_registers = aarch64_linux_fetch_inferior_registers;
 989   t->to_store_registers = aarch64_linux_store_inferior_registers;
 990
 991   t->to_read_description = aarch64_linux_read_description;
 992
 993   t->to_can_use_hw_breakpoint = aarch64_linux_can_use_hw_breakpoint;
 994   t->to_insert_hw_breakpoint = aarch64_linux_insert_hw_breakpoint;
 995   t->to_remove_hw_breakpoint = aarch64_linux_remove_hw_breakpoint;
 996   t->to_region_ok_for_hw_watchpoint =
 997     aarch64_linux_region_ok_for_hw_watchpoint;
 998   t->to_insert_watchpoint = aarch64_linux_insert_watchpoint;
 999   t->to_remove_watchpoint = aarch64_linux_remove_watchpoint;
1000   t->to_stopped_by_watchpoint = aarch64_linux_stopped_by_watchpoint;
1001   t->to_stopped_data_address = aarch64_linux_stopped_data_address;
1002   t->to_watchpoint_addr_within_range =
1003     aarch64_linux_watchpoint_addr_within_range;
1004
1005   /* Override the GNU/Linux inferior startup hook.  */
1006   super_post_startup_inferior = t->to_post_startup_inferior;
1007   t->to_post_startup_inferior = aarch64_linux_child_post_startup_inferior;
1008
1009   /* Register the target.  */
1010   linux_nat_add_target (t);
1011   linux_nat_set_new_thread (t, aarch64_linux_new_thread);
1012   linux_nat_set_new_fork (t, aarch64_linux_new_fork);
1013   linux_nat_set_forget_process (t, aarch64_forget_process);
1014   linux_nat_set_prepare_to_resume (t, aarch64_linux_prepare_to_resume);
1015 }