Add target_ops argument to to_insert_watchpoint
[external/binutils.git] / gdb / aarch64-linux-nat.c
1 /* Native-dependent code for GNU/Linux AArch64.
2
3    Copyright (C) 2011-2014 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 "elf/common.h"
33
34 #include <sys/ptrace.h>
35 #include <sys/utsname.h>
36
37 #include "gregset.h"
38
39 #include "features/aarch64.c"
40
41 /* Defines ps_err_e, struct ps_prochandle.  */
42 #include "gdb_proc_service.h"
43
44 #ifndef TRAP_HWBKPT
45 #define TRAP_HWBKPT 0x0004
46 #endif
47
48 /* On GNU/Linux, threads are implemented as pseudo-processes, in which
49    case we may be tracing more than one process at a time.  In that
50    case, inferior_ptid will contain the main process ID and the
51    individual thread (process) ID.  get_thread_id () is used to get
52    the thread id if it's available, and the process id otherwise.  */
53
54 static int
55 get_thread_id (ptid_t ptid)
56 {
57   int tid = ptid_get_lwp (ptid);
58
59   if (0 == tid)
60     tid = ptid_get_pid (ptid);
61   return tid;
62 }
63
64 /* Macro definitions, data structures, and code for the hardware
65    breakpoint and hardware watchpoint support follow.  We use the
66    following abbreviations throughout the code:
67
68    hw - hardware
69    bp - breakpoint
70    wp - watchpoint  */
71
72 /* Maximum number of hardware breakpoint and watchpoint registers.
73    Neither of these values may exceed the width of dr_changed_t
74    measured in bits.  */
75
76 #define AARCH64_HBP_MAX_NUM 16
77 #define AARCH64_HWP_MAX_NUM 16
78
79 /* Alignment requirement in bytes for addresses written to
80    hardware breakpoint and watchpoint value registers.
81
82    A ptrace call attempting to set an address that does not meet the
83    alignment criteria will fail.  Limited support has been provided in
84    this port for unaligned watchpoints, such that from a GDB user
85    perspective, an unaligned watchpoint may be requested.
86
87    This is achieved by minimally enlarging the watched area to meet the
88    alignment requirement, and if necessary, splitting the watchpoint
89    over several hardware watchpoint registers.  */
90
91 #define AARCH64_HBP_ALIGNMENT 4
92 #define AARCH64_HWP_ALIGNMENT 8
93
94 /* The maximum length of a memory region that can be watched by one
95    hardware watchpoint register.  */
96
97 #define AARCH64_HWP_MAX_LEN_PER_REG 8
98
99 /* ptrace hardware breakpoint resource info is formatted as follows:
100
101    31             24             16               8              0
102    +---------------+--------------+---------------+---------------+
103    |   RESERVED    |   RESERVED   |   DEBUG_ARCH  |  NUM_SLOTS    |
104    +---------------+--------------+---------------+---------------+  */
105
106
107 /* Macros to extract fields from the hardware debug information word.  */
108 #define AARCH64_DEBUG_NUM_SLOTS(x) ((x) & 0xff)
109 #define AARCH64_DEBUG_ARCH(x) (((x) >> 8) & 0xff)
110
111 /* Macro for the expected version of the ARMv8-A debug architecture.  */
112 #define AARCH64_DEBUG_ARCH_V8 0x6
113
114 /* Number of hardware breakpoints/watchpoints the target supports.
115    They are initialized with values obtained via the ptrace calls
116    with NT_ARM_HW_BREAK and NT_ARM_HW_WATCH respectively.  */
117
118 static int aarch64_num_bp_regs;
119 static int aarch64_num_wp_regs;
120
121 /* Debugging of hardware breakpoint/watchpoint support.  */
122
123 static int debug_hw_points;
124
125 /* Each bit of a variable of this type is used to indicate whether a
126    hardware breakpoint or watchpoint setting has been changed since
127    the last update.
128
129    Bit N corresponds to the Nth hardware breakpoint or watchpoint
130    setting which is managed in aarch64_debug_reg_state, where N is
131    valid between 0 and the total number of the hardware breakpoint or
132    watchpoint debug registers minus 1.
133
134    When bit N is 1, the corresponding breakpoint or watchpoint setting
135    has changed, and therefore the corresponding hardware debug
136    register needs to be updated via the ptrace interface.
137
138    In the per-thread arch-specific data area, we define two such
139    variables for per-thread hardware breakpoint and watchpoint
140    settings respectively.
141
142    This type is part of the mechanism which helps reduce the number of
143    ptrace calls to the kernel, i.e. avoid asking the kernel to write
144    to the debug registers with unchanged values.  */
145
146 typedef unsigned LONGEST dr_changed_t;
147
148 /* Set each of the lower M bits of X to 1; assert X is wide enough.  */
149
150 #define DR_MARK_ALL_CHANGED(x, m)                                       \
151   do                                                                    \
152     {                                                                   \
153       gdb_assert (sizeof ((x)) * 8 >= (m));                             \
154       (x) = (((dr_changed_t)1 << (m)) - 1);                             \
155     } while (0)
156
157 #define DR_MARK_N_CHANGED(x, n)                                         \
158   do                                                                    \
159     {                                                                   \
160       (x) |= ((dr_changed_t)1 << (n));                                  \
161     } while (0)
162
163 #define DR_CLEAR_CHANGED(x)                                             \
164   do                                                                    \
165     {                                                                   \
166       (x) = 0;                                                          \
167     } while (0)
168
169 #define DR_HAS_CHANGED(x) ((x) != 0)
170 #define DR_N_HAS_CHANGED(x, n) ((x) & ((dr_changed_t)1 << (n)))
171
172 /* Structure for managing the hardware breakpoint/watchpoint resources.
173    DR_ADDR_* stores the address, DR_CTRL_* stores the control register
174    content, and DR_REF_COUNT_* counts the numbers of references to the
175    corresponding bp/wp, by which way the limited hardware resources
176    are not wasted on duplicated bp/wp settings (though so far gdb has
177    done a good job by not sending duplicated bp/wp requests).  */
178
179 struct aarch64_debug_reg_state
180 {
181   /* hardware breakpoint */
182   CORE_ADDR dr_addr_bp[AARCH64_HBP_MAX_NUM];
183   unsigned int dr_ctrl_bp[AARCH64_HBP_MAX_NUM];
184   unsigned int dr_ref_count_bp[AARCH64_HBP_MAX_NUM];
185
186   /* hardware watchpoint */
187   CORE_ADDR dr_addr_wp[AARCH64_HWP_MAX_NUM];
188   unsigned int dr_ctrl_wp[AARCH64_HWP_MAX_NUM];
189   unsigned int dr_ref_count_wp[AARCH64_HWP_MAX_NUM];
190 };
191
192 /* Per-process data.  We don't bind this to a per-inferior registry
193    because of targets like x86 GNU/Linux that need to keep track of
194    processes that aren't bound to any inferior (e.g., fork children,
195    checkpoints).  */
196
197 struct aarch64_process_info
198 {
199   /* Linked list.  */
200   struct aarch64_process_info *next;
201
202   /* The process identifier.  */
203   pid_t pid;
204
205   /* Copy of aarch64 hardware debug registers.  */
206   struct aarch64_debug_reg_state state;
207 };
208
209 static struct aarch64_process_info *aarch64_process_list = NULL;
210
211 /* Find process data for process PID.  */
212
213 static struct aarch64_process_info *
214 aarch64_find_process_pid (pid_t pid)
215 {
216   struct aarch64_process_info *proc;
217
218   for (proc = aarch64_process_list; proc; proc = proc->next)
219     if (proc->pid == pid)
220       return proc;
221
222   return NULL;
223 }
224
225 /* Add process data for process PID.  Returns newly allocated info
226    object.  */
227
228 static struct aarch64_process_info *
229 aarch64_add_process (pid_t pid)
230 {
231   struct aarch64_process_info *proc;
232
233   proc = xcalloc (1, sizeof (*proc));
234   proc->pid = pid;
235
236   proc->next = aarch64_process_list;
237   aarch64_process_list = proc;
238
239   return proc;
240 }
241
242 /* Get data specific info for process PID, creating it if necessary.
243    Never returns NULL.  */
244
245 static struct aarch64_process_info *
246 aarch64_process_info_get (pid_t pid)
247 {
248   struct aarch64_process_info *proc;
249
250   proc = aarch64_find_process_pid (pid);
251   if (proc == NULL)
252     proc = aarch64_add_process (pid);
253
254   return proc;
255 }
256
257 /* Called whenever GDB is no longer debugging process PID.  It deletes
258    data structures that keep track of debug register state.  */
259
260 static void
261 aarch64_forget_process (pid_t pid)
262 {
263   struct aarch64_process_info *proc, **proc_link;
264
265   proc = aarch64_process_list;
266   proc_link = &aarch64_process_list;
267
268   while (proc != NULL)
269     {
270       if (proc->pid == pid)
271         {
272           *proc_link = proc->next;
273
274           xfree (proc);
275           return;
276         }
277
278       proc_link = &proc->next;
279       proc = *proc_link;
280     }
281 }
282
283 /* Get debug registers state for process PID.  */
284
285 static struct aarch64_debug_reg_state *
286 aarch64_get_debug_reg_state (pid_t pid)
287 {
288   return &aarch64_process_info_get (pid)->state;
289 }
290
291 /* Per-thread arch-specific data we want to keep.  */
292
293 struct arch_lwp_info
294 {
295   /* When bit N is 1, it indicates the Nth hardware breakpoint or
296      watchpoint register pair needs to be updated when the thread is
297      resumed; see aarch64_linux_prepare_to_resume.  */
298   dr_changed_t dr_changed_bp;
299   dr_changed_t dr_changed_wp;
300 };
301
302 /* Call ptrace to set the thread TID's hardware breakpoint/watchpoint
303    registers with data from *STATE.  */
304
305 static void
306 aarch64_linux_set_debug_regs (const struct aarch64_debug_reg_state *state,
307                               int tid, int watchpoint)
308 {
309   int i, count;
310   struct iovec iov;
311   struct user_hwdebug_state regs;
312   const CORE_ADDR *addr;
313   const unsigned int *ctrl;
314
315   memset (&regs, 0, sizeof (regs));
316   iov.iov_base = &regs;
317   count = watchpoint ? aarch64_num_wp_regs : aarch64_num_bp_regs;
318   addr = watchpoint ? state->dr_addr_wp : state->dr_addr_bp;
319   ctrl = watchpoint ? state->dr_ctrl_wp : state->dr_ctrl_bp;
320   if (count == 0)
321     return;
322   iov.iov_len = (offsetof (struct user_hwdebug_state, dbg_regs[count - 1])
323                  + sizeof (regs.dbg_regs [count - 1]));
324
325   for (i = 0; i < count; i++)
326     {
327       regs.dbg_regs[i].addr = addr[i];
328       regs.dbg_regs[i].ctrl = ctrl[i];
329     }
330
331   if (ptrace (PTRACE_SETREGSET, tid,
332               watchpoint ? NT_ARM_HW_WATCH : NT_ARM_HW_BREAK,
333               (void *) &iov))
334     error (_("Unexpected error setting hardware debug registers"));
335 }
336
337 struct aarch64_dr_update_callback_param
338 {
339   int is_watchpoint;
340   unsigned int idx;
341 };
342
343 /* Callback for iterate_over_lwps.  Records the
344    information about the change of one hardware breakpoint/watchpoint
345    setting for the thread LWP.
346    The information is passed in via PTR.
347    N.B.  The actual updating of hardware debug registers is not
348    carried out until the moment the thread is resumed.  */
349
350 static int
351 debug_reg_change_callback (struct lwp_info *lwp, void *ptr)
352 {
353   struct aarch64_dr_update_callback_param *param_p
354     = (struct aarch64_dr_update_callback_param *) ptr;
355   int pid = get_thread_id (lwp->ptid);
356   int idx = param_p->idx;
357   int is_watchpoint = param_p->is_watchpoint;
358   struct arch_lwp_info *info = lwp->arch_private;
359   dr_changed_t *dr_changed_ptr;
360   dr_changed_t dr_changed;
361
362   if (info == NULL)
363     info = lwp->arch_private = XCNEW (struct arch_lwp_info);
364
365   if (debug_hw_points)
366     {
367       fprintf_unfiltered (gdb_stdlog,
368                           "debug_reg_change_callback: \n\tOn entry:\n");
369       fprintf_unfiltered (gdb_stdlog,
370                           "\tpid%d, dr_changed_bp=0x%s, "
371                           "dr_changed_wp=0x%s\n",
372                           pid, phex (info->dr_changed_bp, 8),
373                           phex (info->dr_changed_wp, 8));
374     }
375
376   dr_changed_ptr = is_watchpoint ? &info->dr_changed_wp
377     : &info->dr_changed_bp;
378   dr_changed = *dr_changed_ptr;
379
380   gdb_assert (idx >= 0
381               && (idx <= (is_watchpoint ? aarch64_num_wp_regs
382                           : aarch64_num_bp_regs)));
383
384   /* The actual update is done later just before resuming the lwp,
385      we just mark that one register pair needs updating.  */
386   DR_MARK_N_CHANGED (dr_changed, idx);
387   *dr_changed_ptr = dr_changed;
388
389   /* If the lwp isn't stopped, force it to momentarily pause, so
390      we can update its debug registers.  */
391   if (!lwp->stopped)
392     linux_stop_lwp (lwp);
393
394   if (debug_hw_points)
395     {
396       fprintf_unfiltered (gdb_stdlog,
397                           "\tOn exit:\n\tpid%d, dr_changed_bp=0x%s, "
398                           "dr_changed_wp=0x%s\n",
399                           pid, phex (info->dr_changed_bp, 8),
400                           phex (info->dr_changed_wp, 8));
401     }
402
403   /* Continue the iteration.  */
404   return 0;
405 }
406
407 /* Notify each thread that their IDXth breakpoint/watchpoint register
408    pair needs to be updated.  The message will be recorded in each
409    thread's arch-specific data area, the actual updating will be done
410    when the thread is resumed.  */
411
412 static void
413 aarch64_notify_debug_reg_change (const struct aarch64_debug_reg_state *state,
414                                  int is_watchpoint, unsigned int idx)
415 {
416   struct aarch64_dr_update_callback_param param;
417   ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
418
419   param.is_watchpoint = is_watchpoint;
420   param.idx = idx;
421
422   iterate_over_lwps (pid_ptid, debug_reg_change_callback, (void *) &param);
423 }
424
425 /* Print the values of the cached breakpoint/watchpoint registers.  */
426
427 static void
428 aarch64_show_debug_reg_state (struct aarch64_debug_reg_state *state,
429                               const char *func, CORE_ADDR addr,
430                               int len, int type)
431 {
432   int i;
433
434   fprintf_unfiltered (gdb_stdlog, "%s", func);
435   if (addr || len)
436     fprintf_unfiltered (gdb_stdlog, " (addr=0x%08lx, len=%d, type=%s)",
437                         (unsigned long) addr, len,
438                         type == hw_write ? "hw-write-watchpoint"
439                         : (type == hw_read ? "hw-read-watchpoint"
440                            : (type == hw_access ? "hw-access-watchpoint"
441                               : (type == hw_execute ? "hw-breakpoint"
442                                  : "??unknown??"))));
443   fprintf_unfiltered (gdb_stdlog, ":\n");
444
445   fprintf_unfiltered (gdb_stdlog, "\tBREAKPOINTs:\n");
446   for (i = 0; i < aarch64_num_bp_regs; i++)
447     fprintf_unfiltered (gdb_stdlog,
448                         "\tBP%d: addr=0x%08lx, ctrl=0x%08x, ref.count=%d\n",
449                         i, state->dr_addr_bp[i],
450                         state->dr_ctrl_bp[i], state->dr_ref_count_bp[i]);
451
452   fprintf_unfiltered (gdb_stdlog, "\tWATCHPOINTs:\n");
453   for (i = 0; i < aarch64_num_wp_regs; i++)
454     fprintf_unfiltered (gdb_stdlog,
455                         "\tWP%d: addr=0x%08lx, ctrl=0x%08x, ref.count=%d\n",
456                         i, state->dr_addr_wp[i],
457                         state->dr_ctrl_wp[i], state->dr_ref_count_wp[i]);
458 }
459
460 /* Fill GDB's register array with the general-purpose register values
461    from the current thread.  */
462
463 static void
464 fetch_gregs_from_thread (struct regcache *regcache)
465 {
466   int ret, regno, tid;
467   elf_gregset_t regs;
468   struct iovec iovec;
469
470   tid = get_thread_id (inferior_ptid);
471
472   iovec.iov_base = &regs;
473   iovec.iov_len = sizeof (regs);
474
475   ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
476   if (ret < 0)
477     perror_with_name (_("Unable to fetch general registers."));
478
479   for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
480     regcache_raw_supply (regcache, regno,
481                          (char *) &regs[regno - AARCH64_X0_REGNUM]);
482 }
483
484 /* Store to the current thread the valid general-purpose register
485    values in the GDB's register array.  */
486
487 static void
488 store_gregs_to_thread (const struct regcache *regcache)
489 {
490   int ret, regno, tid;
491   elf_gregset_t regs;
492   struct iovec iovec;
493
494   tid = get_thread_id (inferior_ptid);
495
496   iovec.iov_base = &regs;
497   iovec.iov_len = sizeof (regs);
498
499   ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iovec);
500   if (ret < 0)
501     perror_with_name (_("Unable to fetch general registers."));
502
503   for (regno = AARCH64_X0_REGNUM; regno <= AARCH64_CPSR_REGNUM; regno++)
504     if (REG_VALID == regcache_register_status (regcache, regno))
505       regcache_raw_collect (regcache, regno,
506                             (char *) &regs[regno - AARCH64_X0_REGNUM]);
507
508   ret = ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, &iovec);
509   if (ret < 0)
510     perror_with_name (_("Unable to store general registers."));
511 }
512
513 /* Fill GDB's register array with the fp/simd register values
514    from the current thread.  */
515
516 static void
517 fetch_fpregs_from_thread (struct regcache *regcache)
518 {
519   int ret, regno, tid;
520   elf_fpregset_t regs;
521   struct iovec iovec;
522
523   tid = get_thread_id (inferior_ptid);
524
525   iovec.iov_base = &regs;
526   iovec.iov_len = sizeof (regs);
527
528   ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iovec);
529   if (ret < 0)
530     perror_with_name (_("Unable to fetch FP/SIMD registers."));
531
532   for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
533     regcache_raw_supply (regcache, regno,
534                          (char *) &regs.vregs[regno - AARCH64_V0_REGNUM]);
535
536   regcache_raw_supply (regcache, AARCH64_FPSR_REGNUM, (char *) &regs.fpsr);
537   regcache_raw_supply (regcache, AARCH64_FPCR_REGNUM, (char *) &regs.fpcr);
538 }
539
540 /* Store to the current thread the valid fp/simd register
541    values in the GDB's register array.  */
542
543 static void
544 store_fpregs_to_thread (const struct regcache *regcache)
545 {
546   int ret, regno, tid;
547   elf_fpregset_t regs;
548   struct iovec iovec;
549
550   tid = get_thread_id (inferior_ptid);
551
552   iovec.iov_base = &regs;
553   iovec.iov_len = sizeof (regs);
554
555   ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iovec);
556   if (ret < 0)
557     perror_with_name (_("Unable to fetch FP/SIMD registers."));
558
559   for (regno = AARCH64_V0_REGNUM; regno <= AARCH64_V31_REGNUM; regno++)
560     if (REG_VALID == regcache_register_status (regcache, regno))
561       regcache_raw_collect (regcache, regno,
562                             (char *) &regs.vregs[regno - AARCH64_V0_REGNUM]);
563
564   if (REG_VALID == regcache_register_status (regcache, AARCH64_FPSR_REGNUM))
565     regcache_raw_collect (regcache, AARCH64_FPSR_REGNUM, (char *) &regs.fpsr);
566   if (REG_VALID == regcache_register_status (regcache, AARCH64_FPCR_REGNUM))
567     regcache_raw_collect (regcache, AARCH64_FPCR_REGNUM, (char *) &regs.fpcr);
568
569   ret = ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, &iovec);
570   if (ret < 0)
571     perror_with_name (_("Unable to store FP/SIMD registers."));
572 }
573
574 /* Implement the "to_fetch_register" target_ops method.  */
575
576 static void
577 aarch64_linux_fetch_inferior_registers (struct target_ops *ops,
578                                         struct regcache *regcache,
579                                         int regno)
580 {
581   if (regno == -1)
582     {
583       fetch_gregs_from_thread (regcache);
584       fetch_fpregs_from_thread (regcache);
585     }
586   else if (regno < AARCH64_V0_REGNUM)
587     fetch_gregs_from_thread (regcache);
588   else
589     fetch_fpregs_from_thread (regcache);
590 }
591
592 /* Implement the "to_store_register" target_ops method.  */
593
594 static void
595 aarch64_linux_store_inferior_registers (struct target_ops *ops,
596                                         struct regcache *regcache,
597                                         int regno)
598 {
599   if (regno == -1)
600     {
601       store_gregs_to_thread (regcache);
602       store_fpregs_to_thread (regcache);
603     }
604   else if (regno < AARCH64_V0_REGNUM)
605     store_gregs_to_thread (regcache);
606   else
607     store_fpregs_to_thread (regcache);
608 }
609
610 /* Fill register REGNO (if it is a general-purpose register) in
611    *GREGSETPS with the value in GDB's register array.  If REGNO is -1,
612    do this for all registers.  */
613
614 void
615 fill_gregset (const struct regcache *regcache,
616               gdb_gregset_t *gregsetp, int regno)
617 {
618   gdb_byte *gregs_buf = (gdb_byte *) gregsetp;
619   int i;
620
621   for (i = AARCH64_X0_REGNUM; i <= AARCH64_CPSR_REGNUM; i++)
622     if (regno == -1 || regno == i)
623       regcache_raw_collect (regcache, i,
624                             gregs_buf + X_REGISTER_SIZE
625                             * (i - AARCH64_X0_REGNUM));
626 }
627
628 /* Fill GDB's register array with the general-purpose register values
629    in *GREGSETP.  */
630
631 void
632 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
633 {
634   aarch64_linux_supply_gregset (regcache, (const gdb_byte *) gregsetp);
635 }
636
637 /* Fill register REGNO (if it is a floating-point register) in
638    *FPREGSETP with the value in GDB's register array.  If REGNO is -1,
639    do this for all registers.  */
640
641 void
642 fill_fpregset (const struct regcache *regcache,
643                gdb_fpregset_t *fpregsetp, int regno)
644 {
645   gdb_byte *fpregs_buf = (gdb_byte *) fpregsetp;
646   int i;
647
648   for (i = AARCH64_V0_REGNUM; i <= AARCH64_V31_REGNUM; i++)
649     if (regno == -1 || regno == i)
650       regcache_raw_collect (regcache, i,
651                             fpregs_buf + V_REGISTER_SIZE
652                             * (i - AARCH64_V0_REGNUM));
653
654   if (regno == -1 || regno == AARCH64_FPSR_REGNUM)
655     regcache_raw_collect (regcache, AARCH64_FPSR_REGNUM,
656                           fpregs_buf + V_REGISTER_SIZE * 32);
657
658   if (regno == -1 || regno == AARCH64_FPCR_REGNUM)
659     regcache_raw_collect (regcache, AARCH64_FPCR_REGNUM,
660                           fpregs_buf + V_REGISTER_SIZE * 32 + 4);
661 }
662
663 /* Fill GDB's register array with the floating-point register values
664    in *FPREGSETP.  */
665
666 void
667 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
668 {
669   aarch64_linux_supply_fpregset (regcache, (const gdb_byte *) fpregsetp);
670 }
671
672 /* Called when resuming a thread.
673    The hardware debug registers are updated when there is any change.  */
674
675 static void
676 aarch64_linux_prepare_to_resume (struct lwp_info *lwp)
677 {
678   struct arch_lwp_info *info = lwp->arch_private;
679
680   /* NULL means this is the main thread still going through the shell,
681      or, no watchpoint has been set yet.  In that case, there's
682      nothing to do.  */
683   if (info == NULL)
684     return;
685
686   if (DR_HAS_CHANGED (info->dr_changed_bp)
687       || DR_HAS_CHANGED (info->dr_changed_wp))
688     {
689       int tid = ptid_get_lwp (lwp->ptid);
690       struct aarch64_debug_reg_state *state
691         = aarch64_get_debug_reg_state (ptid_get_pid (lwp->ptid));
692
693       if (debug_hw_points)
694         fprintf_unfiltered (gdb_stdlog, "prepare_to_resume thread %d\n", tid);
695
696       /* Watchpoints.  */
697       if (DR_HAS_CHANGED (info->dr_changed_wp))
698         {
699           aarch64_linux_set_debug_regs (state, tid, 1);
700           DR_CLEAR_CHANGED (info->dr_changed_wp);
701         }
702
703       /* Breakpoints.  */
704       if (DR_HAS_CHANGED (info->dr_changed_bp))
705         {
706           aarch64_linux_set_debug_regs (state, tid, 0);
707           DR_CLEAR_CHANGED (info->dr_changed_bp);
708         }
709     }
710 }
711
712 static void
713 aarch64_linux_new_thread (struct lwp_info *lp)
714 {
715   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
716
717   /* Mark that all the hardware breakpoint/watchpoint register pairs
718      for this thread need to be initialized.  */
719   DR_MARK_ALL_CHANGED (info->dr_changed_bp, aarch64_num_bp_regs);
720   DR_MARK_ALL_CHANGED (info->dr_changed_wp, aarch64_num_wp_regs);
721
722   lp->arch_private = info;
723 }
724
725 /* linux_nat_new_fork hook.   */
726
727 static void
728 aarch64_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
729 {
730   pid_t parent_pid;
731   struct aarch64_debug_reg_state *parent_state;
732   struct aarch64_debug_reg_state *child_state;
733
734   /* NULL means no watchpoint has ever been set in the parent.  In
735      that case, there's nothing to do.  */
736   if (parent->arch_private == NULL)
737     return;
738
739   /* GDB core assumes the child inherits the watchpoints/hw
740      breakpoints of the parent, and will remove them all from the
741      forked off process.  Copy the debug registers mirrors into the
742      new process so that all breakpoints and watchpoints can be
743      removed together.  */
744
745   parent_pid = ptid_get_pid (parent->ptid);
746   parent_state = aarch64_get_debug_reg_state (parent_pid);
747   child_state = aarch64_get_debug_reg_state (child_pid);
748   *child_state = *parent_state;
749 }
750 \f
751
752 /* Called by libthread_db.  Returns a pointer to the thread local
753    storage (or its descriptor).  */
754
755 ps_err_e
756 ps_get_thread_area (const struct ps_prochandle *ph,
757                     lwpid_t lwpid, int idx, void **base)
758 {
759   struct iovec iovec;
760   uint64_t reg;
761
762   iovec.iov_base = &reg;
763   iovec.iov_len = sizeof (reg);
764
765   if (ptrace (PTRACE_GETREGSET, lwpid, NT_ARM_TLS, &iovec) != 0)
766     return PS_ERR;
767
768   /* IDX is the bias from the thread pointer to the beginning of the
769      thread descriptor.  It has to be subtracted due to implementation
770      quirks in libthread_db.  */
771   *base = (void *) (reg - idx);
772
773   return PS_OK;
774 }
775 \f
776
777 /* Get the hardware debug register capacity information.  */
778
779 static void
780 aarch64_linux_get_debug_reg_capacity (void)
781 {
782   int tid;
783   struct iovec iov;
784   struct user_hwdebug_state dreg_state;
785
786   tid = get_thread_id (inferior_ptid);
787   iov.iov_base = &dreg_state;
788   iov.iov_len = sizeof (dreg_state);
789
790   /* Get hardware watchpoint register info.  */
791   if (ptrace (PTRACE_GETREGSET, tid, NT_ARM_HW_WATCH, &iov) == 0
792       && AARCH64_DEBUG_ARCH (dreg_state.dbg_info) == AARCH64_DEBUG_ARCH_V8)
793     {
794       aarch64_num_wp_regs = AARCH64_DEBUG_NUM_SLOTS (dreg_state.dbg_info);
795       if (aarch64_num_wp_regs > AARCH64_HWP_MAX_NUM)
796         {
797           warning (_("Unexpected number of hardware watchpoint registers"
798                      " reported by ptrace, got %d, expected %d."),
799                    aarch64_num_wp_regs, AARCH64_HWP_MAX_NUM);
800           aarch64_num_wp_regs = AARCH64_HWP_MAX_NUM;
801         }
802     }
803   else
804     {
805       warning (_("Unable to determine the number of hardware watchpoints"
806                  " available."));
807       aarch64_num_wp_regs = 0;
808     }
809
810   /* Get hardware breakpoint register info.  */
811   if (ptrace (PTRACE_GETREGSET, tid, NT_ARM_HW_BREAK, &iov) == 0
812       && AARCH64_DEBUG_ARCH (dreg_state.dbg_info) == AARCH64_DEBUG_ARCH_V8)
813     {
814       aarch64_num_bp_regs = AARCH64_DEBUG_NUM_SLOTS (dreg_state.dbg_info);
815       if (aarch64_num_bp_regs > AARCH64_HBP_MAX_NUM)
816         {
817           warning (_("Unexpected number of hardware breakpoint registers"
818                      " reported by ptrace, got %d, expected %d."),
819                    aarch64_num_bp_regs, AARCH64_HBP_MAX_NUM);
820           aarch64_num_bp_regs = AARCH64_HBP_MAX_NUM;
821         }
822     }
823   else
824     {
825       warning (_("Unable to determine the number of hardware breakpoints"
826                  " available."));
827       aarch64_num_bp_regs = 0;
828     }
829 }
830
831 static void (*super_post_startup_inferior) (ptid_t ptid);
832
833 /* Implement the "to_post_startup_inferior" target_ops method.  */
834
835 static void
836 aarch64_linux_child_post_startup_inferior (ptid_t ptid)
837 {
838   aarch64_forget_process (ptid_get_pid (ptid));
839   aarch64_linux_get_debug_reg_capacity ();
840   super_post_startup_inferior (ptid);
841 }
842
843 /* Implement the "to_read_description" target_ops method.  */
844
845 static const struct target_desc *
846 aarch64_linux_read_description (struct target_ops *ops)
847 {
848   initialize_tdesc_aarch64 ();
849   return tdesc_aarch64;
850 }
851
852 /* Given the (potentially unaligned) watchpoint address in ADDR and
853    length in LEN, return the aligned address and aligned length in
854    *ALIGNED_ADDR_P and *ALIGNED_LEN_P, respectively.  The returned
855    aligned address and length will be valid values to write to the
856    hardware watchpoint value and control registers.
857
858    The given watchpoint may get truncated if more than one hardware
859    register is needed to cover the watched region.  *NEXT_ADDR_P
860    and *NEXT_LEN_P, if non-NULL, will return the address and length
861    of the remaining part of the watchpoint (which can be processed
862    by calling this routine again to generate another aligned address
863    and length pair.
864
865    See the comment above the function of the same name in
866    gdbserver/linux-aarch64-low.c for more information.  */
867
868 static void
869 aarch64_align_watchpoint (CORE_ADDR addr, int len, CORE_ADDR *aligned_addr_p,
870                           int *aligned_len_p, CORE_ADDR *next_addr_p,
871                           int *next_len_p)
872 {
873   int aligned_len;
874   unsigned int offset;
875   CORE_ADDR aligned_addr;
876   const unsigned int alignment = AARCH64_HWP_ALIGNMENT;
877   const unsigned int max_wp_len = AARCH64_HWP_MAX_LEN_PER_REG;
878
879   /* As assumed by the algorithm.  */
880   gdb_assert (alignment == max_wp_len);
881
882   if (len <= 0)
883     return;
884
885   /* Address to be put into the hardware watchpoint value register
886      must be aligned.  */
887   offset = addr & (alignment - 1);
888   aligned_addr = addr - offset;
889
890   gdb_assert (offset >= 0 && offset < alignment);
891   gdb_assert (aligned_addr >= 0 && aligned_addr <= addr);
892   gdb_assert (offset + len > 0);
893
894   if (offset + len >= max_wp_len)
895     {
896       /* Need more than one watchpoint registers; truncate it at the
897          alignment boundary.  */
898       aligned_len = max_wp_len;
899       len -= (max_wp_len - offset);
900       addr += (max_wp_len - offset);
901       gdb_assert ((addr & (alignment - 1)) == 0);
902     }
903   else
904     {
905       /* Find the smallest valid length that is large enough to
906          accommodate this watchpoint.  */
907       static const unsigned char
908         aligned_len_array[AARCH64_HWP_MAX_LEN_PER_REG] =
909         { 1, 2, 4, 4, 8, 8, 8, 8 };
910
911       aligned_len = aligned_len_array[offset + len - 1];
912       addr += len;
913       len = 0;
914     }
915
916   if (aligned_addr_p)
917     *aligned_addr_p = aligned_addr;
918   if (aligned_len_p)
919     *aligned_len_p = aligned_len;
920   if (next_addr_p)
921     *next_addr_p = addr;
922   if (next_len_p)
923     *next_len_p = len;
924 }
925
926 /* Returns the number of hardware watchpoints of type TYPE that we can
927    set.  Value is positive if we can set CNT watchpoints, zero if
928    setting watchpoints of type TYPE is not supported, and negative if
929    CNT is more than the maximum number of watchpoints of type TYPE
930    that we can support.  TYPE is one of bp_hardware_watchpoint,
931    bp_read_watchpoint, bp_write_watchpoint, or bp_hardware_breakpoint.
932    CNT is the number of such watchpoints used so far (including this
933    one).  OTHERTYPE is non-zero if other types of watchpoints are
934    currently enabled.
935
936    We always return 1 here because we don't have enough information
937    about possible overlap of addresses that they want to watch.  As an
938    extreme example, consider the case where all the watchpoints watch
939    the same address and the same region length: then we can handle a
940    virtually unlimited number of watchpoints, due to debug register
941    sharing implemented via reference counts.  */
942
943 static int
944 aarch64_linux_can_use_hw_breakpoint (struct target_ops *self,
945                                      int type, int cnt, int othertype)
946 {
947   return 1;
948 }
949
950 /* ptrace expects control registers to be formatted as follows:
951
952    31                             13          5      3      1     0
953    +--------------------------------+----------+------+------+----+
954    |         RESERVED (SBZ)         |  LENGTH  | TYPE | PRIV | EN |
955    +--------------------------------+----------+------+------+----+
956
957    The TYPE field is ignored for breakpoints.  */
958
959 #define DR_CONTROL_ENABLED(ctrl)        (((ctrl) & 0x1) == 1)
960 #define DR_CONTROL_LENGTH(ctrl)         (((ctrl) >> 5) & 0xff)
961
962 /* Utility function that returns the length in bytes of a watchpoint
963    according to the content of a hardware debug control register CTRL.
964    Note that the kernel currently only supports the following Byte
965    Address Select (BAS) values: 0x1, 0x3, 0xf and 0xff, which means
966    that for a hardware watchpoint, its valid length can only be 1
967    byte, 2 bytes, 4 bytes or 8 bytes.  */
968
969 static inline unsigned int
970 aarch64_watchpoint_length (unsigned int ctrl)
971 {
972   switch (DR_CONTROL_LENGTH (ctrl))
973     {
974     case 0x01:
975       return 1;
976     case 0x03:
977       return 2;
978     case 0x0f:
979       return 4;
980     case 0xff:
981       return 8;
982     default:
983       return 0;
984     }
985 }
986
987 /* Given the hardware breakpoint or watchpoint type TYPE and its
988    length LEN, return the expected encoding for a hardware
989    breakpoint/watchpoint control register.  */
990
991 static unsigned int
992 aarch64_point_encode_ctrl_reg (int type, int len)
993 {
994   unsigned int ctrl, ttype;
995
996   /* type */
997   switch (type)
998     {
999     case hw_write:
1000       ttype = 2;
1001       break;
1002     case hw_read:
1003       ttype = 1;
1004       break;
1005     case hw_access:
1006       ttype = 3;
1007       break;
1008     case hw_execute:
1009       ttype = 0;
1010       break;
1011     default:
1012       perror_with_name (_("Unrecognized breakpoint/watchpoint type"));
1013     }
1014   ctrl = ttype << 3;
1015
1016   /* length bitmask */
1017   ctrl |= ((1 << len) - 1) << 5;
1018   /* enabled at el0 */
1019   ctrl |= (2 << 1) | 1;
1020
1021   return ctrl;
1022 }
1023
1024 /* Addresses to be written to the hardware breakpoint and watchpoint
1025    value registers need to be aligned; the alignment is 4-byte and
1026    8-type respectively.  Linux kernel rejects any non-aligned address
1027    it receives from the related ptrace call.  Furthermore, the kernel
1028    currently only supports the following Byte Address Select (BAS)
1029    values: 0x1, 0x3, 0xf and 0xff, which means that for a hardware
1030    watchpoint to be accepted by the kernel (via ptrace call), its
1031    valid length can only be 1 byte, 2 bytes, 4 bytes or 8 bytes.
1032    Despite these limitations, the unaligned watchpoint is supported in
1033    this port.
1034
1035    Return 0 for any non-compliant ADDR and/or LEN; return 1 otherwise.  */
1036
1037 static int
1038 aarch64_point_is_aligned (int is_watchpoint, CORE_ADDR addr, int len)
1039 {
1040   unsigned int alignment = is_watchpoint ? AARCH64_HWP_ALIGNMENT
1041     : AARCH64_HBP_ALIGNMENT;
1042
1043   if (addr & (alignment - 1))
1044     return 0;
1045
1046   if (len != 8 && len != 4 && len != 2 && len != 1)
1047     return 0;
1048
1049   return 1;
1050 }
1051
1052 /* Record the insertion of one breakpoint/watchpoint, as represented
1053    by ADDR and CTRL, in the cached debug register state area *STATE.  */
1054
1055 static int
1056 aarch64_dr_state_insert_one_point (struct aarch64_debug_reg_state *state,
1057                                    int type, CORE_ADDR addr, int len)
1058 {
1059   int i, idx, num_regs, is_watchpoint;
1060   unsigned int ctrl, *dr_ctrl_p, *dr_ref_count;
1061   CORE_ADDR *dr_addr_p;
1062
1063   /* Set up state pointers.  */
1064   is_watchpoint = (type != hw_execute);
1065   gdb_assert (aarch64_point_is_aligned (is_watchpoint, addr, len));
1066   if (is_watchpoint)
1067     {
1068       num_regs = aarch64_num_wp_regs;
1069       dr_addr_p = state->dr_addr_wp;
1070       dr_ctrl_p = state->dr_ctrl_wp;
1071       dr_ref_count = state->dr_ref_count_wp;
1072     }
1073   else
1074     {
1075       num_regs = aarch64_num_bp_regs;
1076       dr_addr_p = state->dr_addr_bp;
1077       dr_ctrl_p = state->dr_ctrl_bp;
1078       dr_ref_count = state->dr_ref_count_bp;
1079     }
1080
1081   ctrl = aarch64_point_encode_ctrl_reg (type, len);
1082
1083   /* Find an existing or free register in our cache.  */
1084   idx = -1;
1085   for (i = 0; i < num_regs; ++i)
1086     {
1087       if ((dr_ctrl_p[i] & 1) == 0)
1088         {
1089           gdb_assert (dr_ref_count[i] == 0);
1090           idx = i;
1091           /* no break; continue hunting for an existing one.  */
1092         }
1093       else if (dr_addr_p[i] == addr && dr_ctrl_p[i] == ctrl)
1094         {
1095           gdb_assert (dr_ref_count[i] != 0);
1096           idx = i;
1097           break;
1098         }
1099     }
1100
1101   /* No space.  */
1102   if (idx == -1)
1103     return -1;
1104
1105   /* Update our cache.  */
1106   if ((dr_ctrl_p[idx] & 1) == 0)
1107     {
1108       /* new entry */
1109       dr_addr_p[idx] = addr;
1110       dr_ctrl_p[idx] = ctrl;
1111       dr_ref_count[idx] = 1;
1112       /* Notify the change.  */
1113       aarch64_notify_debug_reg_change (state, is_watchpoint, idx);
1114     }
1115   else
1116     {
1117       /* existing entry */
1118       dr_ref_count[idx]++;
1119     }
1120
1121   return 0;
1122 }
1123
1124 /* Record the removal of one breakpoint/watchpoint, as represented by
1125    ADDR and CTRL, in the cached debug register state area *STATE.  */
1126
1127 static int
1128 aarch64_dr_state_remove_one_point (struct aarch64_debug_reg_state *state,
1129                                    int type, CORE_ADDR addr, int len)
1130 {
1131   int i, num_regs, is_watchpoint;
1132   unsigned int ctrl, *dr_ctrl_p, *dr_ref_count;
1133   CORE_ADDR *dr_addr_p;
1134
1135   /* Set up state pointers.  */
1136   is_watchpoint = (type != hw_execute);
1137   gdb_assert (aarch64_point_is_aligned (is_watchpoint, addr, len));
1138   if (is_watchpoint)
1139     {
1140       num_regs = aarch64_num_wp_regs;
1141       dr_addr_p = state->dr_addr_wp;
1142       dr_ctrl_p = state->dr_ctrl_wp;
1143       dr_ref_count = state->dr_ref_count_wp;
1144     }
1145   else
1146     {
1147       num_regs = aarch64_num_bp_regs;
1148       dr_addr_p = state->dr_addr_bp;
1149       dr_ctrl_p = state->dr_ctrl_bp;
1150       dr_ref_count = state->dr_ref_count_bp;
1151     }
1152
1153   ctrl = aarch64_point_encode_ctrl_reg (type, len);
1154
1155   /* Find the entry that matches the ADDR and CTRL.  */
1156   for (i = 0; i < num_regs; ++i)
1157     if (dr_addr_p[i] == addr && dr_ctrl_p[i] == ctrl)
1158       {
1159         gdb_assert (dr_ref_count[i] != 0);
1160         break;
1161       }
1162
1163   /* Not found.  */
1164   if (i == num_regs)
1165     return -1;
1166
1167   /* Clear our cache.  */
1168   if (--dr_ref_count[i] == 0)
1169     {
1170       /* Clear the enable bit.  */
1171       ctrl &= ~1;
1172       dr_addr_p[i] = 0;
1173       dr_ctrl_p[i] = ctrl;
1174       /* Notify the change.  */
1175       aarch64_notify_debug_reg_change (state, is_watchpoint, i);
1176     }
1177
1178   return 0;
1179 }
1180
1181 /* Implement insertion and removal of a single breakpoint.  */
1182
1183 static int
1184 aarch64_handle_breakpoint (int type, CORE_ADDR addr, int len, int is_insert)
1185 {
1186   struct aarch64_debug_reg_state *state;
1187
1188   /* The hardware breakpoint on AArch64 should always be 4-byte
1189      aligned.  */
1190   if (!aarch64_point_is_aligned (0 /* is_watchpoint */ , addr, len))
1191     return -1;
1192
1193   state = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1194
1195   if (is_insert)
1196     return aarch64_dr_state_insert_one_point (state, type, addr, len);
1197   else
1198     return aarch64_dr_state_remove_one_point (state, type, addr, len);
1199 }
1200
1201 /* Insert a hardware-assisted breakpoint at BP_TGT->placed_address.
1202    Return 0 on success, -1 on failure.  */
1203
1204 static int
1205 aarch64_linux_insert_hw_breakpoint (struct target_ops *self,
1206                                     struct gdbarch *gdbarch,
1207                                     struct bp_target_info *bp_tgt)
1208 {
1209   int ret;
1210   CORE_ADDR addr = bp_tgt->placed_address;
1211   const int len = 4;
1212   const int type = hw_execute;
1213
1214   if (debug_hw_points)
1215     fprintf_unfiltered
1216       (gdb_stdlog,
1217        "insert_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
1218        (unsigned long) addr, len);
1219
1220   ret = aarch64_handle_breakpoint (type, addr, len, 1 /* is_insert */);
1221
1222   if (debug_hw_points > 1)
1223     {
1224       struct aarch64_debug_reg_state *state
1225         = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1226
1227       aarch64_show_debug_reg_state (state,
1228                                     "insert_hw_watchpoint", addr, len, type);
1229     }
1230
1231   return ret;
1232 }
1233
1234 /* Remove a hardware-assisted breakpoint at BP_TGT->placed_address.
1235    Return 0 on success, -1 on failure.  */
1236
1237 static int
1238 aarch64_linux_remove_hw_breakpoint (struct target_ops *self,
1239                                     struct gdbarch *gdbarch,
1240                                     struct bp_target_info *bp_tgt)
1241 {
1242   int ret;
1243   CORE_ADDR addr = bp_tgt->placed_address;
1244   const int len = 4;
1245   const int type = hw_execute;
1246
1247   if (debug_hw_points)
1248     fprintf_unfiltered
1249       (gdb_stdlog, "remove_hw_breakpoint on entry (addr=0x%08lx, len=%d))\n",
1250        (unsigned long) addr, len);
1251
1252   ret = aarch64_handle_breakpoint (type, addr, len, 0 /* is_insert */);
1253
1254   if (debug_hw_points > 1)
1255     {
1256       struct aarch64_debug_reg_state *state
1257         = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1258
1259       aarch64_show_debug_reg_state (state,
1260                                     "remove_hw_watchpoint", addr, len, type);
1261     }
1262
1263   return ret;
1264 }
1265
1266 /* This is essentially the same as aarch64_handle_breakpoint, apart
1267    from that it is an aligned watchpoint to be handled.  */
1268
1269 static int
1270 aarch64_handle_aligned_watchpoint (int type, CORE_ADDR addr, int len,
1271                                    int is_insert)
1272 {
1273   struct aarch64_debug_reg_state *state
1274     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1275
1276   if (is_insert)
1277     return aarch64_dr_state_insert_one_point (state, type, addr, len);
1278   else
1279     return aarch64_dr_state_remove_one_point (state, type, addr, len);
1280 }
1281
1282 /* Insert/remove unaligned watchpoint by calling
1283    aarch64_align_watchpoint repeatedly until the whole watched region,
1284    as represented by ADDR and LEN, has been properly aligned and ready
1285    to be written to one or more hardware watchpoint registers.
1286    IS_INSERT indicates whether this is an insertion or a deletion.
1287    Return 0 if succeed.  */
1288
1289 static int
1290 aarch64_handle_unaligned_watchpoint (int type, CORE_ADDR addr, int len,
1291                                      int is_insert)
1292 {
1293   struct aarch64_debug_reg_state *state
1294     = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1295
1296   while (len > 0)
1297     {
1298       CORE_ADDR aligned_addr;
1299       int aligned_len, ret;
1300
1301       aarch64_align_watchpoint (addr, len, &aligned_addr, &aligned_len,
1302                                 &addr, &len);
1303
1304       if (is_insert)
1305         ret = aarch64_dr_state_insert_one_point (state, type, aligned_addr,
1306                                                  aligned_len);
1307       else
1308         ret = aarch64_dr_state_remove_one_point (state, type, aligned_addr,
1309                                                  aligned_len);
1310
1311       if (debug_hw_points)
1312         fprintf_unfiltered (gdb_stdlog,
1313 "handle_unaligned_watchpoint: is_insert: %d\n"
1314 "                             aligned_addr: 0x%08lx, aligned_len: %d\n"
1315 "                                next_addr: 0x%08lx,    next_len: %d\n",
1316                  is_insert, aligned_addr, aligned_len, addr, len);
1317
1318       if (ret != 0)
1319         return ret;
1320     }
1321
1322   return 0;
1323 }
1324
1325 /* Implements insertion and removal of a single watchpoint.  */
1326
1327 static int
1328 aarch64_handle_watchpoint (int type, CORE_ADDR addr, int len, int is_insert)
1329 {
1330   if (aarch64_point_is_aligned (1 /* is_watchpoint */ , addr, len))
1331     return aarch64_handle_aligned_watchpoint (type, addr, len, is_insert);
1332   else
1333     return aarch64_handle_unaligned_watchpoint (type, addr, len, is_insert);
1334 }
1335
1336 /* Implement the "to_insert_watchpoint" target_ops method.
1337
1338    Insert a watchpoint to watch a memory region which starts at
1339    address ADDR and whose length is LEN bytes.  Watch memory accesses
1340    of the type TYPE.  Return 0 on success, -1 on failure.  */
1341
1342 static int
1343 aarch64_linux_insert_watchpoint (struct target_ops *self,
1344                                  CORE_ADDR addr, int len, int type,
1345                                  struct expression *cond)
1346 {
1347   int ret;
1348
1349   if (debug_hw_points)
1350     fprintf_unfiltered (gdb_stdlog,
1351                         "insert_watchpoint on entry (addr=0x%08lx, len=%d)\n",
1352                         (unsigned long) addr, len);
1353
1354   gdb_assert (type != hw_execute);
1355
1356   ret = aarch64_handle_watchpoint (type, addr, len, 1 /* is_insert */);
1357
1358   if (debug_hw_points > 1)
1359     {
1360       struct aarch64_debug_reg_state *state
1361         = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1362
1363       aarch64_show_debug_reg_state (state,
1364                                     "insert_watchpoint", addr, len, type);
1365     }
1366
1367   return ret;
1368 }
1369
1370 /* Implement the "to_remove_watchpoint" target_ops method.
1371    Remove a watchpoint that watched the memory region which starts at
1372    address ADDR, whose length is LEN bytes, and for accesses of the
1373    type TYPE.  Return 0 on success, -1 on failure.  */
1374
1375 static int
1376 aarch64_linux_remove_watchpoint (struct target_ops *self,
1377                                  CORE_ADDR addr, int len, int type,
1378                                  struct expression *cond)
1379 {
1380   int ret;
1381
1382   if (debug_hw_points)
1383     fprintf_unfiltered (gdb_stdlog,
1384                         "remove_watchpoint on entry (addr=0x%08lx, len=%d)\n",
1385                         (unsigned long) addr, len);
1386
1387   gdb_assert (type != hw_execute);
1388
1389   ret = aarch64_handle_watchpoint (type, addr, len, 0 /* is_insert */);
1390
1391   if (debug_hw_points > 1)
1392     {
1393       struct aarch64_debug_reg_state *state
1394         = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1395
1396       aarch64_show_debug_reg_state (state,
1397                                     "remove_watchpoint", addr, len, type);
1398     }
1399
1400   return ret;
1401 }
1402
1403 /* Implement the "to_region_ok_for_hw_watchpoint" target_ops method.  */
1404
1405 static int
1406 aarch64_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
1407 {
1408   CORE_ADDR aligned_addr;
1409
1410   /* Can not set watchpoints for zero or negative lengths.  */
1411   if (len <= 0)
1412     return 0;
1413
1414   /* Must have hardware watchpoint debug register(s).  */
1415   if (aarch64_num_wp_regs == 0)
1416     return 0;
1417
1418   /* We support unaligned watchpoint address and arbitrary length,
1419      as long as the size of the whole watched area after alignment
1420      doesn't exceed size of the total area that all watchpoint debug
1421      registers can watch cooperatively.
1422
1423      This is a very relaxed rule, but unfortunately there are
1424      limitations, e.g. false-positive hits, due to limited support of
1425      hardware debug registers in the kernel.  See comment above
1426      aarch64_align_watchpoint for more information.  */
1427
1428   aligned_addr = addr & ~(AARCH64_HWP_MAX_LEN_PER_REG - 1);
1429   if (aligned_addr + aarch64_num_wp_regs * AARCH64_HWP_MAX_LEN_PER_REG
1430       < addr + len)
1431     return 0;
1432
1433   /* All tests passed so we are likely to be able to set the watchpoint.
1434      The reason that it is 'likely' rather than 'must' is because
1435      we don't check the current usage of the watchpoint registers, and
1436      there may not be enough registers available for this watchpoint.
1437      Ideally we should check the cached debug register state, however
1438      the checking is costly.  */
1439   return 1;
1440 }
1441
1442 /* Implement the "to_stopped_data_address" target_ops method.  */
1443
1444 static int
1445 aarch64_linux_stopped_data_address (struct target_ops *target,
1446                                     CORE_ADDR *addr_p)
1447 {
1448   siginfo_t siginfo;
1449   int i, tid;
1450   struct aarch64_debug_reg_state *state;
1451
1452   if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
1453     return 0;
1454
1455   /* This must be a hardware breakpoint.  */
1456   if (siginfo.si_signo != SIGTRAP
1457       || (siginfo.si_code & 0xffff) != TRAP_HWBKPT)
1458     return 0;
1459
1460   /* Check if the address matches any watched address.  */
1461   state = aarch64_get_debug_reg_state (ptid_get_pid (inferior_ptid));
1462   for (i = aarch64_num_wp_regs - 1; i >= 0; --i)
1463     {
1464       const unsigned int len = aarch64_watchpoint_length (state->dr_ctrl_wp[i]);
1465       const CORE_ADDR addr_trap = (CORE_ADDR) siginfo.si_addr;
1466       const CORE_ADDR addr_watch = state->dr_addr_wp[i];
1467
1468       if (state->dr_ref_count_wp[i]
1469           && DR_CONTROL_ENABLED (state->dr_ctrl_wp[i])
1470           && addr_trap >= addr_watch
1471           && addr_trap < addr_watch + len)
1472         {
1473           *addr_p = addr_trap;
1474           return 1;
1475         }
1476     }
1477
1478   return 0;
1479 }
1480
1481 /* Implement the "to_stopped_by_watchpoint" target_ops method.  */
1482
1483 static int
1484 aarch64_linux_stopped_by_watchpoint (struct target_ops *ops)
1485 {
1486   CORE_ADDR addr;
1487
1488   return aarch64_linux_stopped_data_address (ops, &addr);
1489 }
1490
1491 /* Implement the "to_watchpoint_addr_within_range" target_ops method.  */
1492
1493 static int
1494 aarch64_linux_watchpoint_addr_within_range (struct target_ops *target,
1495                                             CORE_ADDR addr,
1496                                             CORE_ADDR start, int length)
1497 {
1498   return start <= addr && start + length - 1 >= addr;
1499 }
1500
1501 /* Define AArch64 maintenance commands.  */
1502
1503 static void
1504 add_show_debug_regs_command (void)
1505 {
1506   /* A maintenance command to enable printing the internal DRi mirror
1507      variables.  */
1508   add_setshow_boolean_cmd ("show-debug-regs", class_maintenance,
1509                            &debug_hw_points, _("\
1510 Set whether to show variables that mirror the AArch64 debug registers."), _("\
1511 Show whether to show variables that mirror the AArch64 debug registers."), _("\
1512 Use \"on\" to enable, \"off\" to disable.\n\
1513 If enabled, the debug registers values are shown when GDB inserts\n\
1514 or removes a hardware breakpoint or watchpoint, and when the inferior\n\
1515 triggers a breakpoint or watchpoint."),
1516                            NULL,
1517                            NULL,
1518                            &maintenance_set_cmdlist,
1519                            &maintenance_show_cmdlist);
1520 }
1521
1522 /* -Wmissing-prototypes.  */
1523 void _initialize_aarch64_linux_nat (void);
1524
1525 void
1526 _initialize_aarch64_linux_nat (void)
1527 {
1528   struct target_ops *t;
1529
1530   /* Fill in the generic GNU/Linux methods.  */
1531   t = linux_target ();
1532
1533   add_show_debug_regs_command ();
1534
1535   /* Add our register access methods.  */
1536   t->to_fetch_registers = aarch64_linux_fetch_inferior_registers;
1537   t->to_store_registers = aarch64_linux_store_inferior_registers;
1538
1539   t->to_read_description = aarch64_linux_read_description;
1540
1541   t->to_can_use_hw_breakpoint = aarch64_linux_can_use_hw_breakpoint;
1542   t->to_insert_hw_breakpoint = aarch64_linux_insert_hw_breakpoint;
1543   t->to_remove_hw_breakpoint = aarch64_linux_remove_hw_breakpoint;
1544   t->to_region_ok_for_hw_watchpoint =
1545     aarch64_linux_region_ok_for_hw_watchpoint;
1546   t->to_insert_watchpoint = aarch64_linux_insert_watchpoint;
1547   t->to_remove_watchpoint = aarch64_linux_remove_watchpoint;
1548   t->to_stopped_by_watchpoint = aarch64_linux_stopped_by_watchpoint;
1549   t->to_stopped_data_address = aarch64_linux_stopped_data_address;
1550   t->to_watchpoint_addr_within_range =
1551     aarch64_linux_watchpoint_addr_within_range;
1552
1553   /* Override the GNU/Linux inferior startup hook.  */
1554   super_post_startup_inferior = t->to_post_startup_inferior;
1555   t->to_post_startup_inferior = aarch64_linux_child_post_startup_inferior;
1556
1557   /* Register the target.  */
1558   linux_nat_add_target (t);
1559   linux_nat_set_new_thread (t, aarch64_linux_new_thread);
1560   linux_nat_set_new_fork (t, aarch64_linux_new_fork);
1561   linux_nat_set_forget_process (t, aarch64_forget_process);
1562   linux_nat_set_prepare_to_resume (t, aarch64_linux_prepare_to_resume);
1563 }