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