Add linux_get_hwcap
[external/binutils.git] / gdb / arm-linux-nat.c
1 /* GNU/Linux on ARM native support.
2    Copyright (C) 1999-2019 Free Software Foundation, Inc.
3
4    This file is part of GDB.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
18
19 #include "defs.h"
20 #include "inferior.h"
21 #include "gdbcore.h"
22 #include "regcache.h"
23 #include "target.h"
24 #include "linux-nat.h"
25 #include "target-descriptions.h"
26 #include "auxv.h"
27 #include "observable.h"
28 #include "gdbthread.h"
29
30 #include "arm-tdep.h"
31 #include "arm-linux-tdep.h"
32 #include "aarch32-linux-nat.h"
33
34 #include <elf/common.h>
35 #include <sys/user.h>
36 #include "nat/gdb_ptrace.h"
37 #include <sys/utsname.h>
38 #include <sys/procfs.h>
39
40 #include "nat/linux-ptrace.h"
41
42 /* Prototypes for supply_gregset etc.  */
43 #include "gregset.h"
44
45 /* Defines ps_err_e, struct ps_prochandle.  */
46 #include "gdb_proc_service.h"
47
48 #ifndef PTRACE_GET_THREAD_AREA
49 #define PTRACE_GET_THREAD_AREA 22
50 #endif
51
52 #ifndef PTRACE_GETWMMXREGS
53 #define PTRACE_GETWMMXREGS 18
54 #define PTRACE_SETWMMXREGS 19
55 #endif
56
57 #ifndef PTRACE_GETVFPREGS
58 #define PTRACE_GETVFPREGS 27
59 #define PTRACE_SETVFPREGS 28
60 #endif
61
62 #ifndef PTRACE_GETHBPREGS
63 #define PTRACE_GETHBPREGS 29
64 #define PTRACE_SETHBPREGS 30
65 #endif
66
67 extern int arm_apcs_32;
68
69 class arm_linux_nat_target final : public linux_nat_target
70 {
71 public:
72   /* Add our register access methods.  */
73   void fetch_registers (struct regcache *, int) override;
74   void store_registers (struct regcache *, int) override;
75
76   /* Add our hardware breakpoint and watchpoint implementation.  */
77   int can_use_hw_breakpoint (enum bptype, int, int) override;
78
79   int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
80
81   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
82
83   int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
84
85   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
86                          struct expression *) override;
87
88   int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
89                          struct expression *) override;
90   bool stopped_by_watchpoint () override;
91
92   bool stopped_data_address (CORE_ADDR *) override;
93
94   bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
95
96   const struct target_desc *read_description () override;
97
98   /* Override linux_nat_target low methods.  */
99
100   /* Handle thread creation and exit.  */
101   void low_new_thread (struct lwp_info *lp) override;
102   void low_delete_thread (struct arch_lwp_info *lp) override;
103   void low_prepare_to_resume (struct lwp_info *lp) override;
104
105   /* Handle process creation and exit.  */
106   void low_new_fork (struct lwp_info *parent, pid_t child_pid) override;
107   void low_forget_process (pid_t pid) override;
108 };
109
110 static arm_linux_nat_target the_arm_linux_nat_target;
111
112 /* Get the whole floating point state of the process and store it
113    into regcache.  */
114
115 static void
116 fetch_fpregs (struct regcache *regcache)
117 {
118   int ret, regno, tid;
119   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
120
121   /* Get the thread id for the ptrace call.  */
122   tid = regcache->ptid ().lwp ();
123
124   /* Read the floating point state.  */
125   if (have_ptrace_getregset == TRIBOOL_TRUE)
126     {
127       struct iovec iov;
128
129       iov.iov_base = &fp;
130       iov.iov_len = ARM_LINUX_SIZEOF_NWFPE;
131
132       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iov);
133     }
134   else
135     ret = ptrace (PT_GETFPREGS, tid, 0, fp);
136
137   if (ret < 0)
138     perror_with_name (_("Unable to fetch the floating point registers."));
139
140   /* Fetch fpsr.  */
141   regcache->raw_supply (ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
142
143   /* Fetch the floating point registers.  */
144   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
145     supply_nwfpe_register (regcache, regno, fp);
146 }
147
148 /* Save the whole floating point state of the process using
149    the contents from regcache.  */
150
151 static void
152 store_fpregs (const struct regcache *regcache)
153 {
154   int ret, regno, tid;
155   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
156
157   /* Get the thread id for the ptrace call.  */
158   tid = regcache->ptid ().lwp ();
159
160   /* Read the floating point state.  */
161   if (have_ptrace_getregset == TRIBOOL_TRUE)
162     {
163       elf_fpregset_t fpregs;
164       struct iovec iov;
165
166       iov.iov_base = &fpregs;
167       iov.iov_len = sizeof (fpregs);
168
169       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iov);
170     }
171   else
172     ret = ptrace (PT_GETFPREGS, tid, 0, fp);
173
174   if (ret < 0)
175     perror_with_name (_("Unable to fetch the floating point registers."));
176
177   /* Store fpsr.  */
178   if (REG_VALID == regcache->get_register_status (ARM_FPS_REGNUM))
179     regcache->raw_collect (ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
180
181   /* Store the floating point registers.  */
182   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
183     if (REG_VALID == regcache->get_register_status (regno))
184       collect_nwfpe_register (regcache, regno, fp);
185
186   if (have_ptrace_getregset == TRIBOOL_TRUE)
187     {
188       struct iovec iov;
189
190       iov.iov_base = &fp;
191       iov.iov_len = ARM_LINUX_SIZEOF_NWFPE;
192
193       ret = ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, &iov);
194     }
195   else
196     ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
197
198   if (ret < 0)
199     perror_with_name (_("Unable to store floating point registers."));
200 }
201
202 /* Fetch all general registers of the process and store into
203    regcache.  */
204
205 static void
206 fetch_regs (struct regcache *regcache)
207 {
208   int ret, tid;
209   elf_gregset_t regs;
210
211   /* Get the thread id for the ptrace call.  */
212   tid = regcache->ptid ().lwp ();
213
214   if (have_ptrace_getregset == TRIBOOL_TRUE)
215     {
216       struct iovec iov;
217
218       iov.iov_base = &regs;
219       iov.iov_len = sizeof (regs);
220
221       ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov);
222     }
223   else
224     ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
225
226   if (ret < 0)
227     perror_with_name (_("Unable to fetch general registers."));
228
229   aarch32_gp_regcache_supply (regcache, (uint32_t *) regs, arm_apcs_32);
230 }
231
232 static void
233 store_regs (const struct regcache *regcache)
234 {
235   int ret, tid;
236   elf_gregset_t regs;
237
238   /* Get the thread id for the ptrace call.  */
239   tid = regcache->ptid ().lwp ();
240
241   /* Fetch the general registers.  */
242   if (have_ptrace_getregset == TRIBOOL_TRUE)
243     {
244       struct iovec iov;
245
246       iov.iov_base = &regs;
247       iov.iov_len = sizeof (regs);
248
249       ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov);
250     }
251   else
252     ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
253
254   if (ret < 0)
255     perror_with_name (_("Unable to fetch general registers."));
256
257   aarch32_gp_regcache_collect (regcache, (uint32_t *) regs, arm_apcs_32);
258
259   if (have_ptrace_getregset == TRIBOOL_TRUE)
260     {
261       struct iovec iov;
262
263       iov.iov_base = &regs;
264       iov.iov_len = sizeof (regs);
265
266       ret = ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, &iov);
267     }
268   else
269     ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
270
271   if (ret < 0)
272     perror_with_name (_("Unable to store general registers."));
273 }
274
275 /* Fetch all WMMX registers of the process and store into
276    regcache.  */
277
278 #define IWMMXT_REGS_SIZE (16 * 8 + 6 * 4)
279
280 static void
281 fetch_wmmx_regs (struct regcache *regcache)
282 {
283   char regbuf[IWMMXT_REGS_SIZE];
284   int ret, regno, tid;
285
286   /* Get the thread id for the ptrace call.  */
287   tid = regcache->ptid ().lwp ();
288
289   ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
290   if (ret < 0)
291     perror_with_name (_("Unable to fetch WMMX registers."));
292
293   for (regno = 0; regno < 16; regno++)
294     regcache->raw_supply (regno + ARM_WR0_REGNUM, &regbuf[regno * 8]);
295
296   for (regno = 0; regno < 2; regno++)
297     regcache->raw_supply (regno + ARM_WCSSF_REGNUM,
298                           &regbuf[16 * 8 + regno * 4]);
299
300   for (regno = 0; regno < 4; regno++)
301     regcache->raw_supply (regno + ARM_WCGR0_REGNUM,
302                           &regbuf[16 * 8 + 2 * 4 + regno * 4]);
303 }
304
305 static void
306 store_wmmx_regs (const struct regcache *regcache)
307 {
308   char regbuf[IWMMXT_REGS_SIZE];
309   int ret, regno, tid;
310
311   /* Get the thread id for the ptrace call.  */
312   tid = regcache->ptid ().lwp ();
313
314   ret = ptrace (PTRACE_GETWMMXREGS, tid, 0, regbuf);
315   if (ret < 0)
316     perror_with_name (_("Unable to fetch WMMX registers."));
317
318   for (regno = 0; regno < 16; regno++)
319     if (REG_VALID == regcache->get_register_status (regno + ARM_WR0_REGNUM))
320       regcache->raw_collect (regno + ARM_WR0_REGNUM, &regbuf[regno * 8]);
321
322   for (regno = 0; regno < 2; regno++)
323     if (REG_VALID == regcache->get_register_status (regno + ARM_WCSSF_REGNUM))
324       regcache->raw_collect (regno + ARM_WCSSF_REGNUM,
325                              &regbuf[16 * 8 + regno * 4]);
326
327   for (regno = 0; regno < 4; regno++)
328     if (REG_VALID == regcache->get_register_status (regno + ARM_WCGR0_REGNUM))
329       regcache->raw_collect (regno + ARM_WCGR0_REGNUM,
330                              &regbuf[16 * 8 + 2 * 4 + regno * 4]);
331
332   ret = ptrace (PTRACE_SETWMMXREGS, tid, 0, regbuf);
333
334   if (ret < 0)
335     perror_with_name (_("Unable to store WMMX registers."));
336 }
337
338 static void
339 fetch_vfp_regs (struct regcache *regcache)
340 {
341   gdb_byte regbuf[VFP_REGS_SIZE];
342   int ret, tid;
343   struct gdbarch *gdbarch = regcache->arch ();
344   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
345
346   /* Get the thread id for the ptrace call.  */
347   tid = regcache->ptid ().lwp ();
348
349   if (have_ptrace_getregset == TRIBOOL_TRUE)
350     {
351       struct iovec iov;
352
353       iov.iov_base = regbuf;
354       iov.iov_len = VFP_REGS_SIZE;
355       ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iov);
356     }
357   else
358     ret = ptrace (PTRACE_GETVFPREGS, tid, 0, regbuf);
359
360   if (ret < 0)
361     perror_with_name (_("Unable to fetch VFP registers."));
362
363   aarch32_vfp_regcache_supply (regcache, regbuf,
364                                tdep->vfp_register_count);
365 }
366
367 static void
368 store_vfp_regs (const struct regcache *regcache)
369 {
370   gdb_byte regbuf[VFP_REGS_SIZE];
371   int ret, tid;
372   struct gdbarch *gdbarch = regcache->arch ();
373   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
374
375   /* Get the thread id for the ptrace call.  */
376   tid = regcache->ptid ().lwp ();
377
378   if (have_ptrace_getregset == TRIBOOL_TRUE)
379     {
380       struct iovec iov;
381
382       iov.iov_base = regbuf;
383       iov.iov_len = VFP_REGS_SIZE;
384       ret = ptrace (PTRACE_GETREGSET, tid, NT_ARM_VFP, &iov);
385     }
386   else
387     ret = ptrace (PTRACE_GETVFPREGS, tid, 0, regbuf);
388
389   if (ret < 0)
390     perror_with_name (_("Unable to fetch VFP registers (for update)."));
391
392   aarch32_vfp_regcache_collect (regcache, regbuf,
393                                 tdep->vfp_register_count);
394
395   if (have_ptrace_getregset == TRIBOOL_TRUE)
396     {
397       struct iovec iov;
398
399       iov.iov_base = regbuf;
400       iov.iov_len = VFP_REGS_SIZE;
401       ret = ptrace (PTRACE_SETREGSET, tid, NT_ARM_VFP, &iov);
402     }
403   else
404     ret = ptrace (PTRACE_SETVFPREGS, tid, 0, regbuf);
405
406   if (ret < 0)
407     perror_with_name (_("Unable to store VFP registers."));
408 }
409
410 /* Fetch registers from the child process.  Fetch all registers if
411    regno == -1, otherwise fetch all general registers or all floating
412    point registers depending upon the value of regno.  */
413
414 void
415 arm_linux_nat_target::fetch_registers (struct regcache *regcache, int regno)
416 {
417   struct gdbarch *gdbarch = regcache->arch ();
418   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
419
420   if (-1 == regno)
421     {
422       fetch_regs (regcache);
423       if (tdep->have_wmmx_registers)
424         fetch_wmmx_regs (regcache);
425       if (tdep->vfp_register_count > 0)
426         fetch_vfp_regs (regcache);
427       if (tdep->have_fpa_registers)
428         fetch_fpregs (regcache);
429     }
430   else
431     {
432       if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
433         fetch_regs (regcache);
434       else if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
435         fetch_fpregs (regcache);
436       else if (tdep->have_wmmx_registers
437                && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
438         fetch_wmmx_regs (regcache);
439       else if (tdep->vfp_register_count > 0
440                && regno >= ARM_D0_REGNUM
441                && (regno < ARM_D0_REGNUM + tdep->vfp_register_count
442                    || regno == ARM_FPSCR_REGNUM))
443         fetch_vfp_regs (regcache);
444     }
445 }
446
447 /* Store registers back into the inferior.  Store all registers if
448    regno == -1, otherwise store all general registers or all floating
449    point registers depending upon the value of regno.  */
450
451 void
452 arm_linux_nat_target::store_registers (struct regcache *regcache, int regno)
453 {
454   struct gdbarch *gdbarch = regcache->arch ();
455   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
456
457   if (-1 == regno)
458     {
459       store_regs (regcache);
460       if (tdep->have_wmmx_registers)
461         store_wmmx_regs (regcache);
462       if (tdep->vfp_register_count > 0)
463         store_vfp_regs (regcache);
464       if (tdep->have_fpa_registers)
465         store_fpregs (regcache);
466     }
467   else
468     {
469       if (regno < ARM_F0_REGNUM || regno == ARM_PS_REGNUM)
470         store_regs (regcache);
471       else if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
472         store_fpregs (regcache);
473       else if (tdep->have_wmmx_registers
474                && regno >= ARM_WR0_REGNUM && regno <= ARM_WCGR7_REGNUM)
475         store_wmmx_regs (regcache);
476       else if (tdep->vfp_register_count > 0
477                && regno >= ARM_D0_REGNUM
478                && (regno < ARM_D0_REGNUM + tdep->vfp_register_count
479                    || regno == ARM_FPSCR_REGNUM))
480         store_vfp_regs (regcache);
481     }
482 }
483
484 /* Wrapper functions for the standard regset handling, used by
485    thread debugging.  */
486
487 void
488 fill_gregset (const struct regcache *regcache,  
489               gdb_gregset_t *gregsetp, int regno)
490 {
491   arm_linux_collect_gregset (NULL, regcache, regno, gregsetp, 0);
492 }
493
494 void
495 supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp)
496 {
497   arm_linux_supply_gregset (NULL, regcache, -1, gregsetp, 0);
498 }
499
500 void
501 fill_fpregset (const struct regcache *regcache,
502                gdb_fpregset_t *fpregsetp, int regno)
503 {
504   arm_linux_collect_nwfpe (NULL, regcache, regno, fpregsetp, 0);
505 }
506
507 /* Fill GDB's register array with the floating-point register values
508    in *fpregsetp.  */
509
510 void
511 supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp)
512 {
513   arm_linux_supply_nwfpe (NULL, regcache, -1, fpregsetp, 0);
514 }
515
516 /* Fetch the thread-local storage pointer for libthread_db.  */
517
518 ps_err_e
519 ps_get_thread_area (struct ps_prochandle *ph,
520                     lwpid_t lwpid, int idx, void **base)
521 {
522   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
523     return PS_ERR;
524
525   /* IDX is the bias from the thread pointer to the beginning of the
526      thread descriptor.  It has to be subtracted due to implementation
527      quirks in libthread_db.  */
528   *base = (void *) ((char *)*base - idx);
529
530   return PS_OK;
531 }
532
533 const struct target_desc *
534 arm_linux_nat_target::read_description ()
535 {
536   CORE_ADDR arm_hwcap = linux_get_hwcap (this);
537
538   if (have_ptrace_getregset == TRIBOOL_UNKNOWN)
539     {
540       elf_gregset_t gpregs;
541       struct iovec iov;
542       int tid = inferior_ptid.lwp ();
543
544       iov.iov_base = &gpregs;
545       iov.iov_len = sizeof (gpregs);
546
547       /* Check if PTRACE_GETREGSET works.  */
548       if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov) < 0)
549         have_ptrace_getregset = TRIBOOL_FALSE;
550       else
551         have_ptrace_getregset = TRIBOOL_TRUE;
552     }
553
554   if (arm_hwcap & HWCAP_IWMMXT)
555     return tdesc_arm_with_iwmmxt;
556
557   if (arm_hwcap & HWCAP_VFP)
558     {
559       int pid;
560       char *buf;
561       const struct target_desc * result = NULL;
562
563       /* NEON implies VFPv3-D32 or no-VFP unit.  Say that we only support
564          Neon with VFPv3-D32.  */
565       if (arm_hwcap & HWCAP_NEON)
566         result = tdesc_arm_with_neon;
567       else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
568         result = tdesc_arm_with_vfpv3;
569       else
570         result = tdesc_arm_with_vfpv2;
571
572       /* Now make sure that the kernel supports reading these
573          registers.  Support was added in 2.6.30.  */
574       pid = inferior_ptid.lwp ();
575       errno = 0;
576       buf = (char *) alloca (VFP_REGS_SIZE);
577       if (ptrace (PTRACE_GETVFPREGS, pid, 0, buf) < 0
578           && errno == EIO)
579         result = NULL;
580
581       return result;
582     }
583
584   return this->beneath ()->read_description ();
585 }
586
587 /* Information describing the hardware breakpoint capabilities.  */
588 struct arm_linux_hwbp_cap
589 {
590   gdb_byte arch;
591   gdb_byte max_wp_length;
592   gdb_byte wp_count;
593   gdb_byte bp_count;
594 };
595
596 /* Since we cannot dynamically allocate subfields of arm_linux_process_info,
597    assume a maximum number of supported break-/watchpoints.  */
598 #define MAX_BPTS 16
599 #define MAX_WPTS 16
600
601 /* Get hold of the Hardware Breakpoint information for the target we are
602    attached to.  Returns NULL if the kernel doesn't support Hardware 
603    breakpoints at all, or a pointer to the information structure.  */
604 static const struct arm_linux_hwbp_cap *
605 arm_linux_get_hwbp_cap (void)
606 {
607   /* The info structure we return.  */
608   static struct arm_linux_hwbp_cap info;
609
610   /* Is INFO in a good state?  -1 means that no attempt has been made to
611      initialize INFO; 0 means an attempt has been made, but it failed; 1
612      means INFO is in an initialized state.  */
613   static int available = -1;
614
615   if (available == -1)
616     {
617       int tid;
618       unsigned int val;
619
620       tid = inferior_ptid.lwp ();
621       if (ptrace (PTRACE_GETHBPREGS, tid, 0, &val) < 0)
622         available = 0;
623       else
624         {
625           info.arch = (gdb_byte)((val >> 24) & 0xff);
626           info.max_wp_length = (gdb_byte)((val >> 16) & 0xff);
627           info.wp_count = (gdb_byte)((val >> 8) & 0xff);
628           info.bp_count = (gdb_byte)(val & 0xff);
629
630       if (info.wp_count > MAX_WPTS)
631         {
632           warning (_("arm-linux-gdb supports %d hardware watchpoints but target \
633                       supports %d"), MAX_WPTS, info.wp_count);
634           info.wp_count = MAX_WPTS;
635         }
636
637       if (info.bp_count > MAX_BPTS)
638         {
639           warning (_("arm-linux-gdb supports %d hardware breakpoints but target \
640                       supports %d"), MAX_BPTS, info.bp_count);
641           info.bp_count = MAX_BPTS;
642         }
643           available = (info.arch != 0);
644         }
645     }
646
647   return available == 1 ? &info : NULL;
648 }
649
650 /* How many hardware breakpoints are available?  */
651 static int
652 arm_linux_get_hw_breakpoint_count (void)
653 {
654   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
655   return cap != NULL ? cap->bp_count : 0;
656 }
657
658 /* How many hardware watchpoints are available?  */
659 static int
660 arm_linux_get_hw_watchpoint_count (void)
661 {
662   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
663   return cap != NULL ? cap->wp_count : 0;
664 }
665
666 /* Have we got a free break-/watch-point available for use?  Returns -1 if
667    there is not an appropriate resource available, otherwise returns 1.  */
668 int
669 arm_linux_nat_target::can_use_hw_breakpoint (enum bptype type,
670                                              int cnt, int ot)
671 {
672   if (type == bp_hardware_watchpoint || type == bp_read_watchpoint
673       || type == bp_access_watchpoint || type == bp_watchpoint)
674     {
675       int count = arm_linux_get_hw_watchpoint_count ();
676
677       if (count == 0)
678         return 0;
679       else if (cnt + ot > count)
680         return -1;
681     }
682   else if (type == bp_hardware_breakpoint)
683     {
684       int count = arm_linux_get_hw_breakpoint_count ();
685
686       if (count == 0)
687         return 0;
688       else if (cnt > count)
689         return -1;
690     }
691   else
692     gdb_assert (FALSE);
693
694   return 1;
695 }
696
697 /* Enum describing the different types of ARM hardware break-/watch-points.  */
698 typedef enum
699 {
700   arm_hwbp_break = 0,
701   arm_hwbp_load = 1,
702   arm_hwbp_store = 2,
703   arm_hwbp_access = 3
704 } arm_hwbp_type;
705
706 /* Type describing an ARM Hardware Breakpoint Control register value.  */
707 typedef unsigned int arm_hwbp_control_t;
708
709 /* Structure used to keep track of hardware break-/watch-points.  */
710 struct arm_linux_hw_breakpoint
711 {
712   /* Address to break on, or being watched.  */
713   unsigned int address;
714   /* Control register for break-/watch- point.  */
715   arm_hwbp_control_t control;
716 };
717
718 /* Structure containing arrays of per process hardware break-/watchpoints
719    for caching address and control information.
720
721    The Linux ptrace interface to hardware break-/watch-points presents the 
722    values in a vector centred around 0 (which is used fo generic information).
723    Positive indicies refer to breakpoint addresses/control registers, negative
724    indices to watchpoint addresses/control registers.
725
726    The Linux vector is indexed as follows:
727       -((i << 1) + 2): Control register for watchpoint i.
728       -((i << 1) + 1): Address register for watchpoint i.
729                     0: Information register.
730        ((i << 1) + 1): Address register for breakpoint i.
731        ((i << 1) + 2): Control register for breakpoint i.
732
733    This structure is used as a per-thread cache of the state stored by the 
734    kernel, so that we don't need to keep calling into the kernel to find a 
735    free breakpoint.
736
737    We treat break-/watch-points with their enable bit clear as being deleted.
738    */
739 struct arm_linux_debug_reg_state
740 {
741   /* Hardware breakpoints for this process.  */
742   struct arm_linux_hw_breakpoint bpts[MAX_BPTS];
743   /* Hardware watchpoints for this process.  */
744   struct arm_linux_hw_breakpoint wpts[MAX_WPTS];
745 };
746
747 /* Per-process arch-specific data we want to keep.  */
748 struct arm_linux_process_info
749 {
750   /* Linked list.  */
751   struct arm_linux_process_info *next;
752   /* The process identifier.  */
753   pid_t pid;
754   /* Hardware break-/watchpoints state information.  */
755   struct arm_linux_debug_reg_state state;
756
757 };
758
759 /* Per-thread arch-specific data we want to keep.  */
760 struct arch_lwp_info
761 {
762   /* Non-zero if our copy differs from what's recorded in the thread.  */
763   char bpts_changed[MAX_BPTS];
764   char wpts_changed[MAX_WPTS];
765 };
766
767 static struct arm_linux_process_info *arm_linux_process_list = NULL;
768
769 /* Find process data for process PID.  */
770
771 static struct arm_linux_process_info *
772 arm_linux_find_process_pid (pid_t pid)
773 {
774   struct arm_linux_process_info *proc;
775
776   for (proc = arm_linux_process_list; proc; proc = proc->next)
777     if (proc->pid == pid)
778       return proc;
779
780   return NULL;
781 }
782
783 /* Add process data for process PID.  Returns newly allocated info
784    object.  */
785
786 static struct arm_linux_process_info *
787 arm_linux_add_process (pid_t pid)
788 {
789   struct arm_linux_process_info *proc;
790
791   proc = XCNEW (struct arm_linux_process_info);
792   proc->pid = pid;
793
794   proc->next = arm_linux_process_list;
795   arm_linux_process_list = proc;
796
797   return proc;
798 }
799
800 /* Get data specific info for process PID, creating it if necessary.
801    Never returns NULL.  */
802
803 static struct arm_linux_process_info *
804 arm_linux_process_info_get (pid_t pid)
805 {
806   struct arm_linux_process_info *proc;
807
808   proc = arm_linux_find_process_pid (pid);
809   if (proc == NULL)
810     proc = arm_linux_add_process (pid);
811
812   return proc;
813 }
814
815 /* Called whenever GDB is no longer debugging process PID.  It deletes
816    data structures that keep track of debug register state.  */
817
818 void
819 arm_linux_nat_target::low_forget_process (pid_t pid)
820 {
821   struct arm_linux_process_info *proc, **proc_link;
822
823   proc = arm_linux_process_list;
824   proc_link = &arm_linux_process_list;
825
826   while (proc != NULL)
827     {
828       if (proc->pid == pid)
829     {
830       *proc_link = proc->next;
831
832       xfree (proc);
833       return;
834     }
835
836       proc_link = &proc->next;
837       proc = *proc_link;
838     }
839 }
840
841 /* Get hardware break-/watchpoint state for process PID.  */
842
843 static struct arm_linux_debug_reg_state *
844 arm_linux_get_debug_reg_state (pid_t pid)
845 {
846   return &arm_linux_process_info_get (pid)->state;
847 }
848
849 /* Initialize an ARM hardware break-/watch-point control register value.
850    BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the 
851    type of break-/watch-point; ENABLE indicates whether the point is enabled.
852    */
853 static arm_hwbp_control_t 
854 arm_hwbp_control_initialize (unsigned byte_address_select,
855                              arm_hwbp_type hwbp_type,
856                              int enable)
857 {
858   gdb_assert ((byte_address_select & ~0xffU) == 0);
859   gdb_assert (hwbp_type != arm_hwbp_break 
860               || ((byte_address_select & 0xfU) != 0));
861
862   return (byte_address_select << 5) | (hwbp_type << 3) | (3 << 1) | enable;
863 }
864
865 /* Does the breakpoint control value CONTROL have the enable bit set?  */
866 static int
867 arm_hwbp_control_is_enabled (arm_hwbp_control_t control)
868 {
869   return control & 0x1;
870 }
871
872 /* Change a breakpoint control word so that it is in the disabled state.  */
873 static arm_hwbp_control_t
874 arm_hwbp_control_disable (arm_hwbp_control_t control)
875 {
876   return control & ~0x1;
877 }
878
879 /* Initialise the hardware breakpoint structure P.  The breakpoint will be
880    enabled, and will point to the placed address of BP_TGT.  */
881 static void
882 arm_linux_hw_breakpoint_initialize (struct gdbarch *gdbarch,
883                                     struct bp_target_info *bp_tgt,
884                                     struct arm_linux_hw_breakpoint *p)
885 {
886   unsigned mask;
887   CORE_ADDR address = bp_tgt->placed_address = bp_tgt->reqstd_address;
888
889   /* We have to create a mask for the control register which says which bits
890      of the word pointed to by address to break on.  */
891   if (arm_pc_is_thumb (gdbarch, address))
892     {
893       mask = 0x3;
894       address &= ~1;
895     }
896   else
897     {
898       mask = 0xf;
899       address &= ~3;
900     }
901
902   p->address = (unsigned int) address;
903   p->control = arm_hwbp_control_initialize (mask, arm_hwbp_break, 1);
904 }
905
906 /* Get the ARM hardware breakpoint type from the TYPE value we're
907    given when asked to set a watchpoint.  */
908 static arm_hwbp_type 
909 arm_linux_get_hwbp_type (enum target_hw_bp_type type)
910 {
911   if (type == hw_read)
912     return arm_hwbp_load;
913   else if (type == hw_write)
914     return arm_hwbp_store;
915   else
916     return arm_hwbp_access;
917 }
918
919 /* Initialize the hardware breakpoint structure P for a watchpoint at ADDR
920    to LEN.  The type of watchpoint is given in RW.  */
921 static void
922 arm_linux_hw_watchpoint_initialize (CORE_ADDR addr, int len,
923                                     enum target_hw_bp_type type,
924                                     struct arm_linux_hw_breakpoint *p)
925 {
926   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
927   unsigned mask;
928
929   gdb_assert (cap != NULL);
930   gdb_assert (cap->max_wp_length != 0);
931
932   mask = (1 << len) - 1;
933
934   p->address = (unsigned int) addr;
935   p->control = arm_hwbp_control_initialize (mask, 
936                                             arm_linux_get_hwbp_type (type), 1);
937 }
938
939 /* Are two break-/watch-points equal?  */
940 static int
941 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint *p1,
942                                const struct arm_linux_hw_breakpoint *p2)
943 {
944   return p1->address == p2->address && p1->control == p2->control;
945 }
946
947 /* Callback to mark a watch-/breakpoint to be updated in all threads of
948    the current process.  */
949
950 static int
951 update_registers_callback (struct lwp_info *lwp, int watch, int index)
952 {
953   if (lwp->arch_private == NULL)
954     lwp->arch_private = XCNEW (struct arch_lwp_info);
955
956   /* The actual update is done later just before resuming the lwp,
957      we just mark that the registers need updating.  */
958   if (watch)
959     lwp->arch_private->wpts_changed[index] = 1;
960   else
961     lwp->arch_private->bpts_changed[index] = 1;
962
963   /* If the lwp isn't stopped, force it to momentarily pause, so
964      we can update its breakpoint registers.  */
965   if (!lwp->stopped)
966     linux_stop_lwp (lwp);
967
968   return 0;
969 }
970
971 /* Insert the hardware breakpoint (WATCHPOINT = 0) or watchpoint (WATCHPOINT
972    =1) BPT for thread TID.  */
973 static void
974 arm_linux_insert_hw_breakpoint1 (const struct arm_linux_hw_breakpoint* bpt, 
975                                  int watchpoint)
976 {
977   int pid;
978   ptid_t pid_ptid;
979   gdb_byte count, i;
980   struct arm_linux_hw_breakpoint* bpts;
981
982   pid = inferior_ptid.pid ();
983   pid_ptid = ptid_t (pid);
984
985   if (watchpoint)
986     {
987       count = arm_linux_get_hw_watchpoint_count ();
988       bpts = arm_linux_get_debug_reg_state (pid)->wpts;
989     }
990   else
991     {
992       count = arm_linux_get_hw_breakpoint_count ();
993       bpts = arm_linux_get_debug_reg_state (pid)->bpts;
994     }
995
996   for (i = 0; i < count; ++i)
997     if (!arm_hwbp_control_is_enabled (bpts[i].control))
998       {
999         bpts[i] = *bpt;
1000         iterate_over_lwps (pid_ptid,
1001                            [=] (struct lwp_info *info)
1002                            {
1003                              return update_registers_callback (info, watchpoint,
1004                                                                i);
1005                            });
1006         break;
1007       }
1008
1009   gdb_assert (i != count);
1010 }
1011
1012 /* Remove the hardware breakpoint (WATCHPOINT = 0) or watchpoint
1013    (WATCHPOINT = 1) BPT for thread TID.  */
1014 static void
1015 arm_linux_remove_hw_breakpoint1 (const struct arm_linux_hw_breakpoint *bpt, 
1016                                  int watchpoint)
1017 {
1018   int pid;
1019   gdb_byte count, i;
1020   ptid_t pid_ptid;
1021   struct arm_linux_hw_breakpoint* bpts;
1022
1023   pid = inferior_ptid.pid ();
1024   pid_ptid = ptid_t (pid);
1025
1026   if (watchpoint)
1027     {
1028       count = arm_linux_get_hw_watchpoint_count ();
1029       bpts = arm_linux_get_debug_reg_state (pid)->wpts;
1030     }
1031   else
1032     {
1033       count = arm_linux_get_hw_breakpoint_count ();
1034       bpts = arm_linux_get_debug_reg_state (pid)->bpts;
1035     }
1036
1037   for (i = 0; i < count; ++i)
1038     if (arm_linux_hw_breakpoint_equal (bpt, bpts + i))
1039       {
1040         bpts[i].control = arm_hwbp_control_disable (bpts[i].control);
1041         iterate_over_lwps (pid_ptid,
1042                            [=] (struct lwp_info *info)
1043                            {
1044                              return update_registers_callback (info, watchpoint,
1045                                                                i);
1046                            });
1047         break;
1048       }
1049
1050   gdb_assert (i != count);
1051 }
1052
1053 /* Insert a Hardware breakpoint.  */
1054 int
1055 arm_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
1056                                             struct bp_target_info *bp_tgt)
1057 {
1058   struct arm_linux_hw_breakpoint p;
1059
1060   if (arm_linux_get_hw_breakpoint_count () == 0)
1061     return -1;
1062
1063   arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p);
1064
1065   arm_linux_insert_hw_breakpoint1 (&p, 0);
1066
1067   return 0;
1068 }
1069
1070 /* Remove a hardware breakpoint.  */
1071 int
1072 arm_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
1073                                             struct bp_target_info *bp_tgt)
1074 {
1075   struct arm_linux_hw_breakpoint p;
1076
1077   if (arm_linux_get_hw_breakpoint_count () == 0)
1078     return -1;
1079
1080   arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p);
1081
1082   arm_linux_remove_hw_breakpoint1 (&p, 0);
1083
1084   return 0;
1085 }
1086
1087 /* Are we able to use a hardware watchpoint for the LEN bytes starting at 
1088    ADDR?  */
1089 int
1090 arm_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
1091 {
1092   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
1093   CORE_ADDR max_wp_length, aligned_addr;
1094
1095   /* Can not set watchpoints for zero or negative lengths.  */
1096   if (len <= 0)
1097     return 0;
1098
1099   /* Need to be able to use the ptrace interface.  */
1100   if (cap == NULL || cap->wp_count == 0)
1101     return 0;
1102
1103   /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
1104      range covered by a watchpoint.  */
1105   max_wp_length = (CORE_ADDR)cap->max_wp_length;
1106   aligned_addr = addr & ~(max_wp_length - 1);
1107
1108   if (aligned_addr + max_wp_length < addr + len)
1109     return 0;
1110
1111   /* The current ptrace interface can only handle watchpoints that are a
1112      power of 2.  */
1113   if ((len & (len - 1)) != 0)
1114     return 0;
1115
1116   /* All tests passed so we must be able to set a watchpoint.  */
1117   return 1;
1118 }
1119
1120 /* Insert a Hardware breakpoint.  */
1121 int
1122 arm_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len,
1123                                          enum target_hw_bp_type rw,
1124                                          struct expression *cond)
1125 {
1126   struct arm_linux_hw_breakpoint p;
1127
1128   if (arm_linux_get_hw_watchpoint_count () == 0)
1129     return -1;
1130
1131   arm_linux_hw_watchpoint_initialize (addr, len, rw, &p);
1132
1133   arm_linux_insert_hw_breakpoint1 (&p, 1);
1134
1135   return 0;
1136 }
1137
1138 /* Remove a hardware breakpoint.  */
1139 int
1140 arm_linux_nat_target::remove_watchpoint (CORE_ADDR addr,
1141                                          int len, enum target_hw_bp_type rw,
1142                                          struct expression *cond)
1143 {
1144   struct arm_linux_hw_breakpoint p;
1145
1146   if (arm_linux_get_hw_watchpoint_count () == 0)
1147     return -1;
1148
1149   arm_linux_hw_watchpoint_initialize (addr, len, rw, &p);
1150
1151   arm_linux_remove_hw_breakpoint1 (&p, 1);
1152
1153   return 0;
1154 }
1155
1156 /* What was the data address the target was stopped on accessing.  */
1157 bool
1158 arm_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p)
1159 {
1160   siginfo_t siginfo;
1161   int slot;
1162
1163   if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
1164     return false;
1165
1166   /* This must be a hardware breakpoint.  */
1167   if (siginfo.si_signo != SIGTRAP
1168       || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
1169     return false;
1170
1171   /* We must be able to set hardware watchpoints.  */
1172   if (arm_linux_get_hw_watchpoint_count () == 0)
1173     return 0;
1174
1175   slot = siginfo.si_errno;
1176
1177   /* If we are in a positive slot then we're looking at a breakpoint and not
1178      a watchpoint.  */
1179   if (slot >= 0)
1180     return false;
1181
1182   *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr;
1183   return true;
1184 }
1185
1186 /* Has the target been stopped by hitting a watchpoint?  */
1187 bool
1188 arm_linux_nat_target::stopped_by_watchpoint ()
1189 {
1190   CORE_ADDR addr;
1191   return stopped_data_address (&addr);
1192 }
1193
1194 bool
1195 arm_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr,
1196                                                     CORE_ADDR start,
1197                                                     int length)
1198 {
1199   return start <= addr && start + length - 1 >= addr;
1200 }
1201
1202 /* Handle thread creation.  We need to copy the breakpoints and watchpoints
1203    in the parent thread to the child thread.  */
1204 void
1205 arm_linux_nat_target::low_new_thread (struct lwp_info *lp)
1206 {
1207   int i;
1208   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
1209
1210   /* Mark that all the hardware breakpoint/watchpoint register pairs
1211      for this thread need to be initialized.  */
1212
1213   for (i = 0; i < MAX_BPTS; i++)
1214     {
1215       info->bpts_changed[i] = 1;
1216       info->wpts_changed[i] = 1;
1217     }
1218
1219   lp->arch_private = info;
1220 }
1221
1222 /* Function to call when a thread is being deleted.  */
1223
1224 void
1225 arm_linux_nat_target::low_delete_thread (struct arch_lwp_info *arch_lwp)
1226 {
1227   xfree (arch_lwp);
1228 }
1229
1230 /* Called when resuming a thread.
1231    The hardware debug registers are updated when there is any change.  */
1232
1233 void
1234 arm_linux_nat_target::low_prepare_to_resume (struct lwp_info *lwp)
1235 {
1236   int pid, i;
1237   struct arm_linux_hw_breakpoint *bpts, *wpts;
1238   struct arch_lwp_info *arm_lwp_info = lwp->arch_private;
1239
1240   pid = lwp->ptid.lwp ();
1241   bpts = arm_linux_get_debug_reg_state (lwp->ptid.pid ())->bpts;
1242   wpts = arm_linux_get_debug_reg_state (lwp->ptid.pid ())->wpts;
1243
1244   /* NULL means this is the main thread still going through the shell,
1245      or, no watchpoint has been set yet.  In that case, there's
1246      nothing to do.  */
1247   if (arm_lwp_info == NULL)
1248     return;
1249
1250   for (i = 0; i < arm_linux_get_hw_breakpoint_count (); i++)
1251     if (arm_lwp_info->bpts_changed[i])
1252       {
1253         errno = 0;
1254         if (arm_hwbp_control_is_enabled (bpts[i].control))
1255           if (ptrace (PTRACE_SETHBPREGS, pid,
1256               (PTRACE_TYPE_ARG3) ((i << 1) + 1), &bpts[i].address) < 0)
1257             perror_with_name (_("Unexpected error setting breakpoint"));
1258
1259         if (bpts[i].control != 0)
1260           if (ptrace (PTRACE_SETHBPREGS, pid,
1261               (PTRACE_TYPE_ARG3) ((i << 1) + 2), &bpts[i].control) < 0)
1262             perror_with_name (_("Unexpected error setting breakpoint"));
1263
1264         arm_lwp_info->bpts_changed[i] = 0;
1265       }
1266
1267   for (i = 0; i < arm_linux_get_hw_watchpoint_count (); i++)
1268     if (arm_lwp_info->wpts_changed[i])
1269       {
1270         errno = 0;
1271         if (arm_hwbp_control_is_enabled (wpts[i].control))
1272           if (ptrace (PTRACE_SETHBPREGS, pid,
1273               (PTRACE_TYPE_ARG3) -((i << 1) + 1), &wpts[i].address) < 0)
1274             perror_with_name (_("Unexpected error setting watchpoint"));
1275
1276         if (wpts[i].control != 0)
1277           if (ptrace (PTRACE_SETHBPREGS, pid,
1278               (PTRACE_TYPE_ARG3) -((i << 1) + 2), &wpts[i].control) < 0)
1279             perror_with_name (_("Unexpected error setting watchpoint"));
1280
1281         arm_lwp_info->wpts_changed[i] = 0;
1282       }
1283 }
1284
1285 /* linux_nat_new_fork hook.  */
1286
1287 void
1288 arm_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid)
1289 {
1290   pid_t parent_pid;
1291   struct arm_linux_debug_reg_state *parent_state;
1292   struct arm_linux_debug_reg_state *child_state;
1293
1294   /* NULL means no watchpoint has ever been set in the parent.  In
1295      that case, there's nothing to do.  */
1296   if (parent->arch_private == NULL)
1297     return;
1298
1299   /* GDB core assumes the child inherits the watchpoints/hw
1300      breakpoints of the parent, and will remove them all from the
1301      forked off process.  Copy the debug registers mirrors into the
1302      new process so that all breakpoints and watchpoints can be
1303      removed together.  */
1304
1305   parent_pid = parent->ptid.pid ();
1306   parent_state = arm_linux_get_debug_reg_state (parent_pid);
1307   child_state = arm_linux_get_debug_reg_state (child_pid);
1308   *child_state = *parent_state;
1309 }
1310
1311 void
1312 _initialize_arm_linux_nat (void)
1313 {
1314   /* Register the target.  */
1315   linux_target = &the_arm_linux_nat_target;
1316   add_inf_child_target (&the_arm_linux_nat_target);
1317 }