gdb/aarch64-linux-nat.c

   1 /* Native-dependent code for GNU/Linux AArch64.
   2
   3    Copyright (C) 2011-2019 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.h"
  34 #include "nat/aarch64-linux-hw-point.h"
  35 #include "nat/aarch64-sve-linux-ptrace.h"
  36
  37 #include "elf/external.h"
  38 #include "elf/common.h"
  39
  40 #include "nat/gdb_ptrace.h"
  41 #include <sys/utsname.h>
  42 #include <asm/ptrace.h>
  43
  44 #include "gregset.h"
  45 #include "linux-tdep.h"
  46
  47 /* Defines ps_err_e, struct ps_prochandle.  */
  48 #include "gdb_proc_service.h"
  49 #include "arch-utils.h"
  50
  51 #ifndef TRAP_HWBKPT
  52 #define TRAP_HWBKPT 0x0004
  53 #endif
  54
  55 class aarch64_linux_nat_target final : public linux_nat_target
  56 {
  57 public:
  58   /* Add our register access methods.  */
  59   void fetch_registers (struct regcache *, int) override;
  60   void store_registers (struct regcache *, int) override;
  61
  62   const struct target_desc *read_description () override;
  63
  64   /* Add our hardware breakpoint and watchpoint implementation.  */
  65   int can_use_hw_breakpoint (enum bptype, int, int) override;
  66   int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
  67   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
  68   int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
  69   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
  70                          struct expression *) override;
  71   int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
  72                          struct expression *) override;
  73   bool stopped_by_watchpoint () override;
  74   bool stopped_data_address (CORE_ADDR *) override;
  75   bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
  76
  77   int can_do_single_step () override;
  78
  79   /* Override the GNU/Linux inferior startup hook.  */
  80   void post_startup_inferior (ptid_t) override;
  81
  82   /* Override the GNU/Linux post attach hook.  */
  83   void post_attach (int pid) override;
  84
  85   /* These three defer to common nat/ code.  */
  86   void low_new_thread (struct lwp_info *lp) override
  87   { aarch64_linux_new_thread (lp); }
  88   void low_delete_thread (struct arch_lwp_info *lp) override
  89   { aarch64_linux_delete_thread (lp); }
  90   void low_prepare_to_resume (struct lwp_info *lp) override
  91   { aarch64_linux_prepare_to_resume (lp); }
  92
  93   void low_new_fork (struct lwp_info *parent, pid_t child_pid) override;
  94   void low_forget_process (pid_t pid) override;
  95
  96   /* Add our siginfo layout converter.  */
  97   bool low_siginfo_fixup (siginfo_t *ptrace, gdb_byte *inf, int direction)
  98     override;
  99
 100   struct gdbarch *thread_architecture (ptid_t) override;
 101 };
 102
 103 static aarch64_linux_nat_target the_aarch64_linux_nat_target;
 104
 105 /* Per-process data.  We don't bind this to a per-inferior registry
 106    because of targets like x86 GNU/Linux that need to keep track of
 107    processes that aren't bound to any inferior (e.g., fork children,
 108    checkpoints).  */
 109
 110 struct aarch64_process_info
 111 {
 112   /* Linked list.  */
 113   struct aarch64_process_info *next;
 114
 115   /* The process identifier.  */
 116   pid_t pid;
 117
 118   /* Copy of aarch64 hardware debug registers.  */
 119   struct aarch64_debug_reg_state state;
 120 };
 121
 122 static struct aarch64_process_info *aarch64_process_list = NULL;
 123
 124 /* Find process data for process PID.  */
 125
 126 static struct aarch64_process_info *
 127 aarch64_find_process_pid (pid_t pid)
 128 {
 129   struct aarch64_process_info *proc;
 130
 131   for (proc = aarch64_process_list; proc; proc = proc->next)
 132     if (proc->pid == pid)
 133       return proc;
 134
 135   return NULL;
 136 }
 137
 138 /* Add process data for process PID.  Returns newly allocated info
 139    object.  */
 140
 141 static struct aarch64_process_info *
 142 aarch64_add_process (pid_t pid)
 143 {
 144   struct aarch64_process_info *proc;
 145
 146   proc = XCNEW (struct aarch64_process_info);
 147   proc->pid = pid;
 148
 149   proc->next = aarch64_process_list;
 150   aarch64_process_list = proc;
 151
 152   return proc;
 153 }
 154
 155 /* Get data specific info for process PID, creating it if necessary.
 156    Never returns NULL.  */
 157
 158 static struct aarch64_process_info *
 159 aarch64_process_info_get (pid_t pid)
 160 {
 161   struct aarch64_process_info *proc;
 162
 163   proc = aarch64_find_process_pid (pid);
 164   if (proc == NULL)
 165     proc = aarch64_add_process (pid);
 166
 167   return proc;
 168 }
 169
 170 /* Called whenever GDB is no longer debugging process PID.  It deletes
 171    data structures that keep track of debug register state.  */
 172
 173 void
 174 aarch64_linux_nat_target::low_forget_process (pid_t pid)
 175 {
 176   struct aarch64_process_info *proc, **proc_link;
 177
 178   proc = aarch64_process_list;
 179   proc_link = &aarch64_process_list;
 180
 181   while (proc != NULL)
 182     {
 183       if (proc->pid == pid)
 184         {
 185           *proc_link = proc->next;
 186
 187           xfree (proc);
 188           return;
 189         }
 190
 191       proc_link = &proc->next;
 192       proc = *proc_link;
 193     }
 194 }
 195
 196 /* Get debug registers state for process PID.  */
 197
 198 struct aarch64_debug_reg_state *
 199 aarch64_get_debug_reg_state (pid_t pid)
 200 {
 201   return &aarch64_process_info_get (pid)->state;
 202 }
 203
 204 /* Fill GDB's register array with the general-purpose register values
 205    from the current thread.  */
 206
 207 static void
 208 fetch_gregs_from_thread (struct regcache *regcache)
 209 {
 210   int ret, tid;
 211   struct gdbarch *gdbarch = regcache->arch ();
 212   elf_gregset_t regs;
 213   struct iovec iovec;
 214
 215   /* Make sure REGS can hold all registers contents on both aarch64
 216      and arm.  */
 217   gdb_static_assert (sizeof (regs) >= 18 * 4);
 218
 219   tid = regcache->ptid ().lwp ();
 220
 221   iovec.iov_base = &regs;
 222   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 223     iovec.iov_len = 18 * 4;
 224   else
 225     iovec.iov_len = sizeof (regs);
 226
 227   ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
 228   if (ret < 0)
 229     perror_with_name (_("Unable to fetch general registers."));
 230
 231   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 232     aarch32_gp_regcache_supply (regcache, (uint32_t *) regs, 1);
 233   else
 234     {
 235       int regno;
 236
 237       for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
 238         regcache->raw_supply (regno, &regs[regno - AARCH64_X0_REGNUM]);
 239     }
 240 }
 241
 242 /* Store to the current thread the valid general-purpose register
 243    values in the GDB's register array.  */
 244
 245 static void
 246 store_gregs_to_thread (const struct regcache *regcache)
 247 {
 248   int ret, tid;
 249   elf_gregset_t regs;
 250   struct iovec iovec;
 251   struct gdbarch *gdbarch = regcache->arch ();
 252
 253   /* Make sure REGS can hold all registers contents on both aarch64
 254      and arm.  */
 255   gdb_static_assert (sizeof (regs) >= 18 * 4);
 256   tid = regcache->ptid ().lwp ();
 257
 258   iovec.iov_base = &regs;
 259   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 260     iovec.iov_len = 18 * 4;
 261   else
 262     iovec.iov_len = sizeof (regs);
 263
 264   ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
 265   if (ret < 0)
 266     perror_with_name (_("Unable to fetch general registers."));
 267
 268   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 269     aarch32_gp_regcache_collect (regcache, (uint32_t *) regs, 1);
 270   else
 271     {
 272       int regno;
 273
 274       for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
 275         if (REG_VALID == regcache->get_register_status (regno))
 276           regcache->raw_collect (regno, &regs[regno - AARCH64_X0_REGNUM]);
 277     }
 278
 279   ret = ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, &iovec);
 280   if (ret < 0)
 281     perror_with_name (_("Unable to store general registers."));
 282 }
 283
 284 /* Fill GDB's register array with the fp/simd register values
 285    from the current thread.  */
 286
 287 static void
 288 fetch_fpregs_from_thread (struct regcache *regcache)
 289 {
 290   int ret, tid;
 291   elf_fpregset_t regs;
 292   struct iovec iovec;
 293   struct gdbarch *gdbarch = regcache->arch ();
 294
 295   /* Make sure REGS can hold all VFP registers contents on both aarch64
 296      and arm.  */
 297   gdb_static_assert (sizeof regs >= VFP_REGS_SIZE);
 298
 299   tid = regcache->ptid ().lwp ();
 300
 301   iovec.iov_base = &regs;
 302
 303   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 304     {
 305       iovec.iov_len = VFP_REGS_SIZE;
 306
 307       ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iovec);
 308       if (ret < 0)
 309         perror_with_name (_("Unable to fetch VFP registers."));
 310
 311       aarch32_vfp_regcache_supply (regcache, (gdb_byte *) &regs, 32);
 312     }
 313   else
 314     {
 315       int regno;
 316
 317       iovec.iov_len = sizeof (regs);
 318
 319       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iovec);
 320       if (ret < 0)
 321         perror_with_name (_("Unable to fetch vFP/SIMD registers."));
 322
 323       for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
 324         regcache->raw_supply (regno, &regs.vregs[regno - AARCH64_V0_REGNUM]);
 325
 326       regcache->raw_supply (AARCH64_FPSR_REGNUM, &regs.fpsr);
 327       regcache->raw_supply (AARCH64_FPCR_REGNUM, &regs.fpcr);
 328     }
 329 }
 330
 331 /* Store to the current thread the valid fp/simd register
 332    values in the GDB's register array.  */
 333
 334 static void
 335 store_fpregs_to_thread (const struct regcache *regcache)
 336 {
 337   int ret, tid;
 338   elf_fpregset_t regs;
 339   struct iovec iovec;
 340   struct gdbarch *gdbarch = regcache->arch ();
 341
 342   /* Make sure REGS can hold all VFP registers contents on both aarch64
 343      and arm.  */
 344   gdb_static_assert (sizeof regs >= VFP_REGS_SIZE);
 345   tid = regcache->ptid ().lwp ();
 346
 347   iovec.iov_base = &regs;
 348
 349   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 350     {
 351       iovec.iov_len = VFP_REGS_SIZE;
 352
 353       ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iovec);
 354       if (ret < 0)
 355         perror_with_name (_("Unable to fetch VFP registers."));
 356
 357       aarch32_vfp_regcache_collect (regcache, (gdb_byte *) &regs, 32);
 358     }
 359   else
 360     {
 361       int regno;
 362
 363       iovec.iov_len = sizeof (regs);
 364
 365       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iovec);
 366       if (ret < 0)
 367         perror_with_name (_("Unable to fetch FP/SIMD registers."));
 368
 369       for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
 370         if (REG_VALID == regcache->get_register_status (regno))
 371           regcache->raw_collect
 372             (regno, (char *) &regs.vregs[regno - AARCH64_V0_REGNUM]);
 373
 374       if (REG_VALID == regcache->get_register_status (AARCH64_FPSR_REGNUM))
 375         regcache->raw_collect (AARCH64_FPSR_REGNUM, (char *) &regs.fpsr);
 376       if (REG_VALID == regcache->get_register_status (AARCH64_FPCR_REGNUM))
 377         regcache->raw_collect (AARCH64_FPCR_REGNUM, (char *) &regs.fpcr);
 378     }
 379
 380   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 381     {
 382       ret = ptrace (PTRACE_SETREGSET, tid, NT_ARM_VFP, &iovec);
 383       if (ret < 0)
 384         perror_with_name (_("Unable to store VFP registers."));
 385     }
 386   else
 387     {
 388       ret = ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, &iovec);
 389       if (ret < 0)
 390         perror_with_name (_("Unable to store FP/SIMD registers."));
 391     }
 392 }
 393
 394 /* Fill GDB's register array with the sve register values
 395    from the current thread.  */
 396
 397 static void
 398 fetch_sveregs_from_thread (struct regcache *regcache)
 399 {
 400   std::unique_ptr<gdb_byte[]> base
 401     = aarch64_sve_get_sveregs (regcache->ptid ().lwp ());
 402   aarch64_sve_regs_copy_to_reg_buf (regcache, base.get ());
 403 }
 404
 405 /* Store to the current thread the valid sve register
 406    values in the GDB's register array.  */
 407
 408 static void
 409 store_sveregs_to_thread (struct regcache *regcache)
 410 {
 411   int ret;
 412   struct iovec iovec;
 413   int tid = regcache->ptid ().lwp ();
 414
 415   /* Obtain a dump of SVE registers from ptrace.  */
 416   std::unique_ptr<gdb_byte[]> base = aarch64_sve_get_sveregs (tid);
 417
 418   /* Overwrite with regcache state.  */
 419   aarch64_sve_regs_copy_from_reg_buf (regcache, base.get ());
 420
 421   /* Write back to the kernel.  */
 422   iovec.iov_base = base.get ();
 423   iovec.iov_len = ((struct user_sve_header *) base.get ())->size;
 424   ret = ptrace (PTRACE_SETREGSET, tid, NT_ARM_SVE, &iovec);
 425
 426   if (ret < 0)
 427     perror_with_name (_("Unable to store sve registers"));
 428 }
 429
 430 /* Fill GDB's register array with the pointer authentication mask values from
 431    the current thread.  */
 432
 433 static void
 434 fetch_pauth_masks_from_thread (struct regcache *regcache)
 435 {
 436   struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
 437   int ret;
 438   struct iovec iovec;
 439   uint64_t pauth_regset[2] = {0, 0};
 440   int tid = regcache->ptid ().lwp ();
 441
 442   iovec.iov_base = &pauth_regset;
 443   iovec.iov_len = sizeof (pauth_regset);
 444
 445   ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_PAC_MASK, &iovec);
 446   if (ret != 0)
 447     perror_with_name (_("unable to fetch pauth registers."));
 448
 449   regcache->raw_supply (AARCH64_PAUTH_DMASK_REGNUM (tdep->pauth_reg_base),
 450                         &pauth_regset[0]);
 451   regcache->raw_supply (AARCH64_PAUTH_CMASK_REGNUM (tdep->pauth_reg_base),
 452                         &pauth_regset[1]);
 453 }
 454
 455 /* Implement the "fetch_registers" target_ops method.  */
 456
 457 void
 458 aarch64_linux_nat_target::fetch_registers (struct regcache *regcache,
 459                                            int regno)
 460 {
 461   struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
 462
 463   if (regno == -1)
 464     {
 465       fetch_gregs_from_thread (regcache);
 466       if (tdep->has_sve ())
 467         fetch_sveregs_from_thread (regcache);
 468       else
 469         fetch_fpregs_from_thread (regcache);
 470
 471       if (tdep->has_pauth ())
 472         fetch_pauth_masks_from_thread (regcache);
 473     }
 474   else if (regno < AARCH64_V0_REGNUM)
 475     fetch_gregs_from_thread (regcache);
 476   else if (tdep->has_sve ())
 477     fetch_sveregs_from_thread (regcache);
 478   else
 479     fetch_fpregs_from_thread (regcache);
 480
 481   if (tdep->has_pauth ())
 482     {
 483       if (regno == AARCH64_PAUTH_DMASK_REGNUM (tdep->pauth_reg_base)
 484           || regno == AARCH64_PAUTH_CMASK_REGNUM (tdep->pauth_reg_base))
 485         fetch_pauth_masks_from_thread (regcache);
 486     }
 487 }
 488
 489 /* Implement the "store_registers" target_ops method.  */
 490
 491 void
 492 aarch64_linux_nat_target::store_registers (struct regcache *regcache,
 493                                            int regno)
 494 {
 495   struct gdbarch_tdep *tdep = gdbarch_tdep (regcache->arch ());
 496
 497   if (regno == -1)
 498     {
 499       store_gregs_to_thread (regcache);
 500       if (tdep->has_sve ())
 501         store_sveregs_to_thread (regcache);
 502       else
 503         store_fpregs_to_thread (regcache);
 504     }
 505   else if (regno < AARCH64_V0_REGNUM)
 506     store_gregs_to_thread (regcache);
 507   else if (tdep->has_sve ())
 508     store_sveregs_to_thread (regcache);
 509   else
 510     store_fpregs_to_thread (regcache);
 511 }
 512
 513 /* Fill register REGNO (if it is a general-purpose register) in
 514    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
 515    do this for all registers.  */
 516
 517 void
 518 fill_gregset (const struct regcache *regcache,
 519               gdb_gregset_t *gregsetp, int regno)
 520 {
 521   regcache_collect_regset (&aarch64_linux_gregset, regcache,
 522                            regno, (gdb_byte *) gregsetp,
 523                            AARCH64_LINUX_SIZEOF_GREGSET);
 524 }
 525
 526 /* Fill GDB's register array with the general-purpose register values
 527    in *GREGSETP.  */
 528
 529 void
 530 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
 531 {
 532   regcache_supply_regset (&aarch64_linux_gregset, regcache, -1,
 533                           (const gdb_byte *) gregsetp,
 534                           AARCH64_LINUX_SIZEOF_GREGSET);
 535 }
 536
 537 /* Fill register REGNO (if it is a floating-point register) in
 538    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
 539    do this for all registers.  */
 540
 541 void
 542 fill_fpregset (const struct regcache *regcache,
 543                gdb_fpregset_t *fpregsetp, int regno)
 544 {
 545   regcache_collect_regset (&aarch64_linux_fpregset, regcache,
 546                            regno, (gdb_byte *) fpregsetp,
 547                            AARCH64_LINUX_SIZEOF_FPREGSET);
 548 }
 549
 550 /* Fill GDB's register array with the floating-point register values
 551    in *FPREGSETP.  */
 552
 553 void
 554 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
 555 {
 556   regcache_supply_regset (&aarch64_linux_fpregset, regcache, -1,
 557                           (const gdb_byte *) fpregsetp,
 558                           AARCH64_LINUX_SIZEOF_FPREGSET);
 559 }
 560
 561 /* linux_nat_new_fork hook.   */
 562
 563 void
 564 aarch64_linux_nat_target::low_new_fork (struct lwp_info *parent,
 565                                         pid_t child_pid)
 566 {
 567   pid_t parent_pid;
 568   struct aarch64_debug_reg_state *parent_state;
 569   struct aarch64_debug_reg_state *child_state;
 570
 571   /* NULL means no watchpoint has ever been set in the parent.  In
 572      that case, there's nothing to do.  */
 573   if (parent->arch_private == NULL)
 574     return;
 575
 576   /* GDB core assumes the child inherits the watchpoints/hw
 577      breakpoints of the parent, and will remove them all from the
 578      forked off process.  Copy the debug registers mirrors into the
 579      new process so that all breakpoints and watchpoints can be
 580      removed together.  */
 581
 582   parent_pid = parent->ptid.pid ();
 583   parent_state = aarch64_get_debug_reg_state (parent_pid);
 584   child_state = aarch64_get_debug_reg_state (child_pid);
 585   *child_state = *parent_state;
 586 }
 587 \f
 588
 589 /* Called by libthread_db.  Returns a pointer to the thread local
 590    storage (or its descriptor).  */
 591
 592 ps_err_e
 593 ps_get_thread_area (struct ps_prochandle *ph,
 594                     lwpid_t lwpid, int idx, void **base)
 595 {
 596   int is_64bit_p
 597     = (gdbarch_bfd_arch_info (target_gdbarch ())->bits_per_word == 64);
 598
 599   return aarch64_ps_get_thread_area (ph, lwpid, idx, base, is_64bit_p);
 600 }
 601 \f
 602
 603 /* Implement the "post_startup_inferior" target_ops method.  */
 604
 605 void
 606 aarch64_linux_nat_target::post_startup_inferior (ptid_t ptid)
 607 {
 608   low_forget_process (ptid.pid ());
 609   aarch64_linux_get_debug_reg_capacity (ptid.pid ());
 610   linux_nat_target::post_startup_inferior (ptid);
 611 }
 612
 613 /* Implement the "post_attach" target_ops method.  */
 614
 615 void
 616 aarch64_linux_nat_target::post_attach (int pid)
 617 {
 618   low_forget_process (pid);
 619   /* Set the hardware debug register capacity.  If
 620      aarch64_linux_get_debug_reg_capacity is not called
 621      (as it is in aarch64_linux_child_post_startup_inferior) then
 622      software watchpoints will be used instead of hardware
 623      watchpoints when attaching to a target.  */
 624   aarch64_linux_get_debug_reg_capacity (pid);
 625   linux_nat_target::post_attach (pid);
 626 }
 627
 628 extern struct target_desc *tdesc_arm_with_neon;
 629
 630 /* Implement the "read_description" target_ops method.  */
 631
 632 const struct target_desc *
 633 aarch64_linux_nat_target::read_description ()
 634 {
 635   int ret, tid;
 636   gdb_byte regbuf[VFP_REGS_SIZE];
 637   struct iovec iovec;
 638
 639   tid = inferior_ptid.lwp ();
 640
 641   iovec.iov_base = regbuf;
 642   iovec.iov_len = VFP_REGS_SIZE;
 643
 644   ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iovec);
 645   if (ret == 0)
 646     return tdesc_arm_with_neon;
 647
 648   CORE_ADDR hwcap = linux_get_hwcap (this);
 649
 650   return aarch64_read_description (aarch64_sve_get_vq (tid),
 651                                    hwcap & AARCH64_HWCAP_PACA);
 652 }
 653
 654 /* Convert a native/host siginfo object, into/from the siginfo in the
 655    layout of the inferiors' architecture.  Returns true if any
 656    conversion was done; false otherwise.  If DIRECTION is 1, then copy
 657    from INF to NATIVE.  If DIRECTION is 0, copy from NATIVE to
 658    INF.  */
 659
 660 bool
 661 aarch64_linux_nat_target::low_siginfo_fixup (siginfo_t *native, gdb_byte *inf,
 662                                              int direction)
 663 {
 664   struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
 665
 666   /* Is the inferior 32-bit?  If so, then do fixup the siginfo
 667      object.  */
 668   if (gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 32)
 669     {
 670       if (direction == 0)
 671         aarch64_compat_siginfo_from_siginfo ((struct compat_siginfo *) inf,
 672                                              native);
 673       else
 674         aarch64_siginfo_from_compat_siginfo (native,
 675                                              (struct compat_siginfo *) inf);
 676
 677       return true;
 678     }
 679
 680   return false;
 681 }
 682
 683 /* Returns the number of hardware watchpoints of type TYPE that we can
 684    set.  Value is positive if we can set CNT watchpoints, zero if
 685    setting watchpoints of type TYPE is not supported, and negative if
 686    CNT is more than the maximum number of watchpoints of type TYPE
 687    that we can support.  TYPE is one of bp_hardware_watchpoint,
 688    bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
 689    CNT is the number of such watchpoints used so far (including this
 690    one).  OTHERTYPE is non-zero if other types of watchpoints are
 691    currently enabled.  */
 692
 693 int
 694 aarch64_linux_nat_target::can_use_hw_breakpoint (enum bptype type,
 695                                                  int cnt, int othertype)
 696 {
 697   if (type == bp_hardware_watchpoint || type == bp_read_watchpoint
 698       || type == bp_access_watchpoint || type == bp_watchpoint)
 699     {
 700       if (aarch64_num_wp_regs == 0)
 701         return 0;
 702     }
 703   else if (type == bp_hardware_breakpoint)
 704     {
 705       if (aarch64_num_bp_regs == 0)
 706         return 0;
 707     }
 708   else
 709     gdb_assert_not_reached ("unexpected breakpoint type");
 710
 711   /* We always return 1 here because we don't have enough information
 712      about possible overlap of addresses that they want to watch.  As an
 713      extreme example, consider the case where all the watchpoints watch
 714      the same address and the same region length: then we can handle a
 715      virtually unlimited number of watchpoints, due to debug register
 716      sharing implemented via reference counts.  */
 717   return 1;
 718 }
 719
 720 /* Insert a hardware-assisted breakpoint at BP_TGT->reqstd_address.
 721    Return 0 on success, -1 on failure.  */
 722
 723 int
 724 aarch64_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
 725                                                 struct bp_target_info *bp_tgt)
 726 {
 727   int ret;
 728   CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
 729   int len;
 730   const enum target_hw_bp_type type = hw_execute;
 731   struct aarch64_debug_reg_state *state
 732     = aarch64_get_debug_reg_state (inferior_ptid.pid ());
 733
 734   gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
 735
 736   if (show_debug_regs)
 737     fprintf_unfiltered
 738       (gdb_stdlog,
 739        "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
 740        (unsigned long) addr, len);
 741
 742   ret = aarch64_handle_breakpoint (type, addr, len, 1 /* is_insert */, state);
 743
 744   if (show_debug_regs)
 745     {
 746       aarch64_show_debug_reg_state (state,
 747                                     "insert_hw_breakpoint", addr, len, type);
 748     }
 749
 750   return ret;
 751 }
 752
 753 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
 754    Return 0 on success, -1 on failure.  */
 755
 756 int
 757 aarch64_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
 758                                                 struct bp_target_info *bp_tgt)
 759 {
 760   int ret;
 761   CORE_ADDR addr = bp_tgt->placed_address;
 762   int len = 4;
 763   const enum target_hw_bp_type type = hw_execute;
 764   struct aarch64_debug_reg_state *state
 765     = aarch64_get_debug_reg_state (inferior_ptid.pid ());
 766
 767   gdbarch_breakpoint_from_pc (gdbarch, &addr, &len);
 768
 769   if (show_debug_regs)
 770     fprintf_unfiltered
 771       (gdb_stdlog, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
 772        (unsigned long) addr, len);
 773
 774   ret = aarch64_handle_breakpoint (type, addr, len, 0 /* is_insert */, state);
 775
 776   if (show_debug_regs)
 777     {
 778       aarch64_show_debug_reg_state (state,
 779                                     "remove_hw_watchpoint", addr, len, type);
 780     }
 781
 782   return ret;
 783 }
 784
 785 /* Implement the "insert_watchpoint" target_ops method.
 786
 787    Insert a watchpoint to watch a memory region which starts at
 788    address ADDR and whose length is LEN bytes.  Watch memory accesses
 789    of the type TYPE.  Return 0 on success, -1 on failure.  */
 790
 791 int
 792 aarch64_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len,
 793                                              enum target_hw_bp_type type,
 794                                              struct expression *cond)
 795 {
 796   int ret;
 797   struct aarch64_debug_reg_state *state
 798     = aarch64_get_debug_reg_state (inferior_ptid.pid ());
 799
 800   if (show_debug_regs)
 801     fprintf_unfiltered (gdb_stdlog,
 802                         "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
 803                         (unsigned long) addr, len);
 804
 805   gdb_assert (type != hw_execute);
 806
 807   ret = aarch64_handle_watchpoint (type, addr, len, 1 /* is_insert */, state);
 808
 809   if (show_debug_regs)
 810     {
 811       aarch64_show_debug_reg_state (state,
 812                                     "insert_watchpoint", addr, len, type);
 813     }
 814
 815   return ret;
 816 }
 817
 818 /* Implement the "remove_watchpoint" target_ops method.
 819    Remove a watchpoint that watched the memory region which starts at
 820    address ADDR, whose length is LEN bytes, and for accesses of the
 821    type TYPE.  Return 0 on success, -1 on failure.  */
 822
 823 int
 824 aarch64_linux_nat_target::remove_watchpoint (CORE_ADDR addr, int len,
 825                                              enum target_hw_bp_type type,
 826                                              struct expression *cond)
 827 {
 828   int ret;
 829   struct aarch64_debug_reg_state *state
 830     = aarch64_get_debug_reg_state (inferior_ptid.pid ());
 831
 832   if (show_debug_regs)
 833     fprintf_unfiltered (gdb_stdlog,
 834                         "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
 835                         (unsigned long) addr, len);
 836
 837   gdb_assert (type != hw_execute);
 838
 839   ret = aarch64_handle_watchpoint (type, addr, len, 0 /* is_insert */, state);
 840
 841   if (show_debug_regs)
 842     {
 843       aarch64_show_debug_reg_state (state,
 844                                     "remove_watchpoint", addr, len, type);
 845     }
 846
 847   return ret;
 848 }
 849
 850 /* Implement the "region_ok_for_hw_watchpoint" target_ops method.  */
 851
 852 int
 853 aarch64_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
 854 {
 855   return aarch64_linux_region_ok_for_watchpoint (addr, len);
 856 }
 857
 858 /* Implement the "stopped_data_address" target_ops method.  */
 859
 860 bool
 861 aarch64_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p)
 862 {
 863   siginfo_t siginfo;
 864   int i;
 865   struct aarch64_debug_reg_state *state;
 866
 867   if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
 868     return false;
 869
 870   /* This must be a hardware breakpoint.  */
 871   if (siginfo.si_signo != SIGTRAP
 872       || (siginfo.si_code & 0xffff) != TRAP_HWBKPT)
 873     return false;
 874
 875   /* Check if the address matches any watched address.  */
 876   state = aarch64_get_debug_reg_state (inferior_ptid.pid ());
 877   for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
 878     {
 879       const unsigned int offset
 880         = aarch64_watchpoint_offset (state->dr_ctrl_wp[i]);
 881       const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
 882       const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
 883       const CORE_ADDR addr_watch = state->dr_addr_wp[i] + offset;
 884       const CORE_ADDR addr_watch_aligned = align_down (state->dr_addr_wp[i], 8);
 885       const CORE_ADDR addr_orig = state->dr_addr_orig_wp[i];
 886
 887       if (state->dr_ref_count_wp[i]
 888           && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
 889           && addr_trap >= addr_watch_aligned
 890           && addr_trap < addr_watch + len)
 891         {
 892           /* ADDR_TRAP reports the first address of the memory range
 893              accessed by the CPU, regardless of what was the memory
 894              range watched.  Thus, a large CPU access that straddles
 895              the ADDR_WATCH..ADDR_WATCH+LEN range may result in an
 896              ADDR_TRAP that is lower than the
 897              ADDR_WATCH..ADDR_WATCH+LEN range.  E.g.:
 898
 899              addr: |   4   |   5   |   6   |   7   |   8   |
 900                                    |---- range watched ----|
 901                    |----------- range accessed ------------|
 902
 903              In this case, ADDR_TRAP will be 4.
 904
 905              To match a watchpoint known to GDB core, we must never
 906              report *ADDR_P outside of any ADDR_WATCH..ADDR_WATCH+LEN
 907              range.  ADDR_WATCH <= ADDR_TRAP < ADDR_ORIG is a false
 908              positive on kernels older than 4.10.  See PR
 909              external/20207.  */
 910           *addr_p = addr_orig;
 911           return true;
 912         }
 913     }
 914
 915   return false;
 916 }
 917
 918 /* Implement the "stopped_by_watchpoint" target_ops method.  */
 919
 920 bool
 921 aarch64_linux_nat_target::stopped_by_watchpoint ()
 922 {
 923   CORE_ADDR addr;
 924
 925   return stopped_data_address (&addr);
 926 }
 927
 928 /* Implement the "watchpoint_addr_within_range" target_ops method.  */
 929
 930 bool
 931 aarch64_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr,
 932                                                         CORE_ADDR start, int length)
 933 {
 934   return start <= addr && start + length - 1 >= addr;
 935 }
 936
 937 /* Implement the "can_do_single_step" target_ops method.  */
 938
 939 int
 940 aarch64_linux_nat_target::can_do_single_step ()
 941 {
 942   return 1;
 943 }
 944
 945 /* Implement the "thread_architecture" target_ops method.  */
 946
 947 struct gdbarch *
 948 aarch64_linux_nat_target::thread_architecture (ptid_t ptid)
 949 {
 950   /* Return the gdbarch for the current thread.  If the vector length has
 951      changed since the last time this was called, then do a further lookup.  */
 952
 953   uint64_t vq = aarch64_sve_get_vq (ptid.lwp ());
 954
 955   /* Find the current gdbarch the same way as process_stratum_target.  Only
 956      return it if the current vector length matches the one in the tdep.  */
 957   inferior *inf = find_inferior_ptid (ptid);
 958   gdb_assert (inf != NULL);
 959   if (vq == gdbarch_tdep (inf->gdbarch)->vq)
 960     return inf->gdbarch;
 961
 962   /* We reach here if the vector length for the thread is different from its
 963      value at process start.  Lookup gdbarch via info (potentially creating a
 964      new one), stashing the vector length inside id.  Use -1 for when SVE
 965      unavailable, to distinguish from an unset value of 0.  */
 966   struct gdbarch_info info;
 967   gdbarch_info_init (&info);
 968   info.bfd_arch_info = bfd_lookup_arch (bfd_arch_spu, bfd_mach_spu);
 969   info.id = (int *) (vq == 0 ? -1 : vq);
 970   return gdbarch_find_by_info (info);
 971 }
 972
 973 /* Define AArch64 maintenance commands.  */
 974
 975 static void
 976 add_show_debug_regs_command (void)
 977 {
 978   /* A maintenance command to enable printing the internal DRi mirror
 979      variables.  */
 980   add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
 981                            &show_debug_regs, _("\
 982 Set whether to show variables that mirror the AArch64 debug registers."), _("\
 983 Show whether to show variables that mirror the AArch64 debug registers."), _("\
 984 Use \"on\" to enable, \"off\" to disable.\n\
 985 If enabled, the debug registers values are shown when GDB inserts\n\
 986 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
 987 triggers a breakpoint or watchpoint."),
 988                            NULL,
 989                            NULL,
 990                            &maintenance_set_cmdlist,
 991                            &maintenance_show_cmdlist);
 992 }
 993
 994 void
 995 _initialize_aarch64_linux_nat (void)
 996 {
 997   add_show_debug_regs_command ();
 998
 999   /* Register the target.  */
1000   linux_target = &the_aarch64_linux_nat_target;
1001   add_inf_child_target (&the_aarch64_linux_nat_target);
1002 }