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