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 "aarch32-tdep.h"
  31 #include "arm-tdep.h"
  32 #include "arm-linux-tdep.h"
  33 #include "aarch32-linux-nat.h"
  34
  35 #include <elf/common.h>
  36 #include <sys/user.h>
  37 #include "nat/gdb_ptrace.h"
  38 #include <sys/utsname.h>
  39 #include <sys/procfs.h>
  40
  41 #include "nat/linux-ptrace.h"
  42 #include "linux-tdep.h"
  43
  44 /* Prototypes for supply_gregset etc.  */
  45 #include "gregset.h"
  46
  47 /* Defines ps_err_e, struct ps_prochandle.  */
  48 #include "gdb_proc_service.h"
  49
  50 #ifndef PTRACE_GET_THREAD_AREA
  51 #define PTRACE_GET_THREAD_AREA 22
  52 #endif
  53
  54 #ifndef PTRACE_GETWMMXREGS
  55 #define PTRACE_GETWMMXREGS 18
  56 #define PTRACE_SETWMMXREGS 19
  57 #endif
  58
  59 #ifndef PTRACE_GETVFPREGS
  60 #define PTRACE_GETVFPREGS 27
  61 #define PTRACE_SETVFPREGS 28
  62 #endif
  63
  64 #ifndef PTRACE_GETHBPREGS
  65 #define PTRACE_GETHBPREGS 29
  66 #define PTRACE_SETHBPREGS 30
  67 #endif
  68
  69 extern int arm_apcs_32;
  70
  71 class arm_linux_nat_target final : public linux_nat_target
  72 {
  73 public:
  74   /* Add our register access methods.  */
  75   void fetch_registers (struct regcache *, int) override;
  76   void store_registers (struct regcache *, int) override;
  77
  78   /* Add our hardware breakpoint and watchpoint implementation.  */
  79   int can_use_hw_breakpoint (enum bptype, int, int) override;
  80
  81   int insert_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
  82
  83   int remove_hw_breakpoint (struct gdbarch *, struct bp_target_info *) override;
  84
  85   int region_ok_for_hw_watchpoint (CORE_ADDR, int) override;
  86
  87   int insert_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
  88                          struct expression *) override;
  89
  90   int remove_watchpoint (CORE_ADDR, int, enum target_hw_bp_type,
  91                          struct expression *) override;
  92   bool stopped_by_watchpoint () override;
  93
  94   bool stopped_data_address (CORE_ADDR *) override;
  95
  96   bool watchpoint_addr_within_range (CORE_ADDR, CORE_ADDR, int) override;
  97
  98   const struct target_desc *read_description () override;
  99
 100   /* Override linux_nat_target low methods.  */
 101
 102   /* Handle thread creation and exit.  */
 103   void low_new_thread (struct lwp_info *lp) override;
 104   void low_delete_thread (struct arch_lwp_info *lp) override;
 105   void low_prepare_to_resume (struct lwp_info *lp) override;
 106
 107   /* Handle process creation and exit.  */
 108   void low_new_fork (struct lwp_info *parent, pid_t child_pid) override;
 109   void low_forget_process (pid_t pid) override;
 110 };
 111
 112 static arm_linux_nat_target the_arm_linux_nat_target;
 113
 114 /* Get the whole floating point state of the process and store it
 115    into regcache.  */
 116
 117 static void
 118 fetch_fpregs (struct regcache *regcache)
 119 {
 120   int ret, regno, tid;
 121   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 122
 123   /* Get the thread id for the ptrace call.  */
 124   tid = regcache->ptid ().lwp ();
 125
 126   /* Read the floating point state.  */
 127   if (have_ptrace_getregset == TRIBOOL_TRUE)
 128     {
 129       struct iovec iov;
 130
 131       iov.iov_base = &fp;
 132       iov.iov_len = ARM_LINUX_SIZEOF_NWFPE;
 133
 134       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iov);
 135     }
 136   else
 137     ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 138
 139   if (ret < 0)
 140     perror_with_name (_("Unable to fetch the floating point registers."));
 141
 142   /* Fetch fpsr.  */
 143   regcache->raw_supply (ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
 144
 145   /* Fetch the floating point registers.  */
 146   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 147     supply_nwfpe_register (regcache, regno, fp);
 148 }
 149
 150 /* Save the whole floating point state of the process using
 151    the contents from regcache.  */
 152
 153 static void
 154 store_fpregs (const struct regcache *regcache)
 155 {
 156   int ret, regno, tid;
 157   gdb_byte fp[ARM_LINUX_SIZEOF_NWFPE];
 158
 159   /* Get the thread id for the ptrace call.  */
 160   tid = regcache->ptid ().lwp ();
 161
 162   /* Read the floating point state.  */
 163   if (have_ptrace_getregset == TRIBOOL_TRUE)
 164     {
 165       elf_fpregset_t fpregs;
 166       struct iovec iov;
 167
 168       iov.iov_base = &fpregs;
 169       iov.iov_len = sizeof (fpregs);
 170
 171       ret = ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET, &iov);
 172     }
 173   else
 174     ret = ptrace (PT_GETFPREGS, tid, 0, fp);
 175
 176   if (ret < 0)
 177     perror_with_name (_("Unable to fetch the floating point registers."));
 178
 179   /* Store fpsr.  */
 180   if (REG_VALID == regcache->get_register_status (ARM_FPS_REGNUM))
 181     regcache->raw_collect (ARM_FPS_REGNUM, fp + NWFPE_FPSR_OFFSET);
 182
 183   /* Store the floating point registers.  */
 184   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 185     if (REG_VALID == regcache->get_register_status (regno))
 186       collect_nwfpe_register (regcache, regno, fp);
 187
 188   if (have_ptrace_getregset == TRIBOOL_TRUE)
 189     {
 190       struct iovec iov;
 191
 192       iov.iov_base = &fp;
 193       iov.iov_len = ARM_LINUX_SIZEOF_NWFPE;
 194
 195       ret = ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET, &iov);
 196     }
 197   else
 198     ret = ptrace (PTRACE_SETFPREGS, tid, 0, fp);
 199
 200   if (ret < 0)
 201     perror_with_name (_("Unable to store floating point registers."));
 202 }
 203
 204 /* Fetch all general registers of the process and store into
 205    regcache.  */
 206
 207 static void
 208 fetch_regs (struct regcache *regcache)
 209 {
 210   int ret, tid;
 211   elf_gregset_t regs;
 212
 213   /* Get the thread id for the ptrace call.  */
 214   tid = regcache->ptid ().lwp ();
 215
 216   if (have_ptrace_getregset == TRIBOOL_TRUE)
 217     {
 218       struct iovec iov;
 219
 220       iov.iov_base = &regs;
 221       iov.iov_len = sizeof (regs);
 222
 223       ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov);
 224     }
 225   else
 226     ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 227
 228   if (ret < 0)
 229     perror_with_name (_("Unable to fetch general registers."));
 230
 231   aarch32_gp_regcache_supply (regcache, (uint32_t *) regs, arm_apcs_32);
 232 }
 233
 234 static void
 235 store_regs (const struct regcache *regcache)
 236 {
 237   int ret, tid;
 238   elf_gregset_t regs;
 239
 240   /* Get the thread id for the ptrace call.  */
 241   tid = regcache->ptid ().lwp ();
 242
 243   /* Fetch the general registers.  */
 244   if (have_ptrace_getregset == TRIBOOL_TRUE)
 245     {
 246       struct iovec iov;
 247
 248       iov.iov_base = &regs;
 249       iov.iov_len = sizeof (regs);
 250
 251       ret = ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov);
 252     }
 253   else
 254     ret = ptrace (PTRACE_GETREGS, tid, 0, &regs);
 255
 256   if (ret < 0)
 257     perror_with_name (_("Unable to fetch general registers."));
 258
 259   aarch32_gp_regcache_collect (regcache, (uint32_t *) regs, arm_apcs_32);
 260
 261   if (have_ptrace_getregset == TRIBOOL_TRUE)
 262     {
 263       struct iovec iov;
 264
 265       iov.iov_base = &regs;
 266       iov.iov_len = sizeof (regs);
 267
 268       ret = ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS, &iov);
 269     }
 270   else
 271     ret = ptrace (PTRACE_SETREGS, tid, 0, &regs);
 272
 273   if (ret < 0)
 274     perror_with_name (_("Unable to store general registers."));
 275 }
 276
 277 /* Fetch all WMMX registers of the process and store into
 278    regcache.  */
 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[ARM_VFP3_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 = ARM_VFP3_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[ARM_VFP3_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 = ARM_VFP3_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 = ARM_VFP3_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 arm_read_description (ARM_FP_TYPE_IWMMXT);
 556
 557   if (arm_hwcap & HWCAP_VFP)
 558     {
 559       /* Make sure that the kernel supports reading VFP registers.  Support was
 560          added in 2.6.30.  */
 561       int pid = inferior_ptid.lwp ();
 562       errno = 0;
 563       char *buf = (char *) alloca (ARM_VFP3_REGS_SIZE);
 564       if (ptrace (PTRACE_GETVFPREGS, pid, 0, buf) < 0 && errno == EIO)
 565         return nullptr;
 566
 567       /* NEON implies VFPv3-D32 or no-VFP unit.  Say that we only support
 568          Neon with VFPv3-D32.  */
 569       if (arm_hwcap & HWCAP_NEON)
 570         return aarch32_read_description ();
 571       else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
 572         return arm_read_description (ARM_FP_TYPE_VFPV3);
 573
 574       return arm_read_description (ARM_FP_TYPE_VFPV2);
 575     }
 576
 577   return this->beneath ()->read_description ();
 578 }
 579
 580 /* Information describing the hardware breakpoint capabilities.  */
 581 struct arm_linux_hwbp_cap
 582 {
 583   gdb_byte arch;
 584   gdb_byte max_wp_length;
 585   gdb_byte wp_count;
 586   gdb_byte bp_count;
 587 };
 588
 589 /* Since we cannot dynamically allocate subfields of arm_linux_process_info,
 590    assume a maximum number of supported break-/watchpoints.  */
 591 #define MAX_BPTS 16
 592 #define MAX_WPTS 16
 593
 594 /* Get hold of the Hardware Breakpoint information for the target we are
 595    attached to.  Returns NULL if the kernel doesn't support Hardware
 596    breakpoints at all, or a pointer to the information structure.  */
 597 static const struct arm_linux_hwbp_cap *
 598 arm_linux_get_hwbp_cap (void)
 599 {
 600   /* The info structure we return.  */
 601   static struct arm_linux_hwbp_cap info;
 602
 603   /* Is INFO in a good state?  -1 means that no attempt has been made to
 604      initialize INFO; 0 means an attempt has been made, but it failed; 1
 605      means INFO is in an initialized state.  */
 606   static int available = -1;
 607
 608   if (available == -1)
 609     {
 610       int tid;
 611       unsigned int val;
 612
 613       tid = inferior_ptid.lwp ();
 614       if (ptrace (PTRACE_GETHBPREGS, tid, 0, &val) < 0)
 615         available = 0;
 616       else
 617         {
 618           info.arch = (gdb_byte)((val >> 24) & 0xff);
 619           info.max_wp_length = (gdb_byte)((val >> 16) & 0xff);
 620           info.wp_count = (gdb_byte)((val >> 8) & 0xff);
 621           info.bp_count = (gdb_byte)(val & 0xff);
 622
 623       if (info.wp_count > MAX_WPTS)
 624         {
 625           warning (_("arm-linux-gdb supports %d hardware watchpoints but target \
 626                       supports %d"), MAX_WPTS, info.wp_count);
 627           info.wp_count = MAX_WPTS;
 628         }
 629
 630       if (info.bp_count > MAX_BPTS)
 631         {
 632           warning (_("arm-linux-gdb supports %d hardware breakpoints but target \
 633                       supports %d"), MAX_BPTS, info.bp_count);
 634           info.bp_count = MAX_BPTS;
 635         }
 636           available = (info.arch != 0);
 637         }
 638     }
 639
 640   return available == 1 ? &info : NULL;
 641 }
 642
 643 /* How many hardware breakpoints are available?  */
 644 static int
 645 arm_linux_get_hw_breakpoint_count (void)
 646 {
 647   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
 648   return cap != NULL ? cap->bp_count : 0;
 649 }
 650
 651 /* How many hardware watchpoints are available?  */
 652 static int
 653 arm_linux_get_hw_watchpoint_count (void)
 654 {
 655   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
 656   return cap != NULL ? cap->wp_count : 0;
 657 }
 658
 659 /* Have we got a free break-/watch-point available for use?  Returns -1 if
 660    there is not an appropriate resource available, otherwise returns 1.  */
 661 int
 662 arm_linux_nat_target::can_use_hw_breakpoint (enum bptype type,
 663                                              int cnt, int ot)
 664 {
 665   if (type == bp_hardware_watchpoint || type == bp_read_watchpoint
 666       || type == bp_access_watchpoint || type == bp_watchpoint)
 667     {
 668       int count = arm_linux_get_hw_watchpoint_count ();
 669
 670       if (count == 0)
 671         return 0;
 672       else if (cnt + ot > count)
 673         return -1;
 674     }
 675   else if (type == bp_hardware_breakpoint)
 676     {
 677       int count = arm_linux_get_hw_breakpoint_count ();
 678
 679       if (count == 0)
 680         return 0;
 681       else if (cnt > count)
 682         return -1;
 683     }
 684   else
 685     gdb_assert_not_reached ("unknown breakpoint type");
 686
 687   return 1;
 688 }
 689
 690 /* Enum describing the different types of ARM hardware break-/watch-points.  */
 691 typedef enum
 692 {
 693   arm_hwbp_break = 0,
 694   arm_hwbp_load = 1,
 695   arm_hwbp_store = 2,
 696   arm_hwbp_access = 3
 697 } arm_hwbp_type;
 698
 699 /* Type describing an ARM Hardware Breakpoint Control register value.  */
 700 typedef unsigned int arm_hwbp_control_t;
 701
 702 /* Structure used to keep track of hardware break-/watch-points.  */
 703 struct arm_linux_hw_breakpoint
 704 {
 705   /* Address to break on, or being watched.  */
 706   unsigned int address;
 707   /* Control register for break-/watch- point.  */
 708   arm_hwbp_control_t control;
 709 };
 710
 711 /* Structure containing arrays of per process hardware break-/watchpoints
 712    for caching address and control information.
 713
 714    The Linux ptrace interface to hardware break-/watch-points presents the
 715    values in a vector centred around 0 (which is used fo generic information).
 716    Positive indicies refer to breakpoint addresses/control registers, negative
 717    indices to watchpoint addresses/control registers.
 718
 719    The Linux vector is indexed as follows:
 720       -((i << 1) + 2): Control register for watchpoint i.
 721       -((i << 1) + 1): Address register for watchpoint i.
 722                     0: Information register.
 723        ((i << 1) + 1): Address register for breakpoint i.
 724        ((i << 1) + 2): Control register for breakpoint i.
 725
 726    This structure is used as a per-thread cache of the state stored by the
 727    kernel, so that we don't need to keep calling into the kernel to find a
 728    free breakpoint.
 729
 730    We treat break-/watch-points with their enable bit clear as being deleted.
 731    */
 732 struct arm_linux_debug_reg_state
 733 {
 734   /* Hardware breakpoints for this process.  */
 735   struct arm_linux_hw_breakpoint bpts[MAX_BPTS];
 736   /* Hardware watchpoints for this process.  */
 737   struct arm_linux_hw_breakpoint wpts[MAX_WPTS];
 738 };
 739
 740 /* Per-process arch-specific data we want to keep.  */
 741 struct arm_linux_process_info
 742 {
 743   /* Linked list.  */
 744   struct arm_linux_process_info *next;
 745   /* The process identifier.  */
 746   pid_t pid;
 747   /* Hardware break-/watchpoints state information.  */
 748   struct arm_linux_debug_reg_state state;
 749
 750 };
 751
 752 /* Per-thread arch-specific data we want to keep.  */
 753 struct arch_lwp_info
 754 {
 755   /* Non-zero if our copy differs from what's recorded in the thread.  */
 756   char bpts_changed[MAX_BPTS];
 757   char wpts_changed[MAX_WPTS];
 758 };
 759
 760 static struct arm_linux_process_info *arm_linux_process_list = NULL;
 761
 762 /* Find process data for process PID.  */
 763
 764 static struct arm_linux_process_info *
 765 arm_linux_find_process_pid (pid_t pid)
 766 {
 767   struct arm_linux_process_info *proc;
 768
 769   for (proc = arm_linux_process_list; proc; proc = proc->next)
 770     if (proc->pid == pid)
 771       return proc;
 772
 773   return NULL;
 774 }
 775
 776 /* Add process data for process PID.  Returns newly allocated info
 777    object.  */
 778
 779 static struct arm_linux_process_info *
 780 arm_linux_add_process (pid_t pid)
 781 {
 782   struct arm_linux_process_info *proc;
 783
 784   proc = XCNEW (struct arm_linux_process_info);
 785   proc->pid = pid;
 786
 787   proc->next = arm_linux_process_list;
 788   arm_linux_process_list = proc;
 789
 790   return proc;
 791 }
 792
 793 /* Get data specific info for process PID, creating it if necessary.
 794    Never returns NULL.  */
 795
 796 static struct arm_linux_process_info *
 797 arm_linux_process_info_get (pid_t pid)
 798 {
 799   struct arm_linux_process_info *proc;
 800
 801   proc = arm_linux_find_process_pid (pid);
 802   if (proc == NULL)
 803     proc = arm_linux_add_process (pid);
 804
 805   return proc;
 806 }
 807
 808 /* Called whenever GDB is no longer debugging process PID.  It deletes
 809    data structures that keep track of debug register state.  */
 810
 811 void
 812 arm_linux_nat_target::low_forget_process (pid_t pid)
 813 {
 814   struct arm_linux_process_info *proc, **proc_link;
 815
 816   proc = arm_linux_process_list;
 817   proc_link = &arm_linux_process_list;
 818
 819   while (proc != NULL)
 820     {
 821       if (proc->pid == pid)
 822     {
 823       *proc_link = proc->next;
 824
 825       xfree (proc);
 826       return;
 827     }
 828
 829       proc_link = &proc->next;
 830       proc = *proc_link;
 831     }
 832 }
 833
 834 /* Get hardware break-/watchpoint state for process PID.  */
 835
 836 static struct arm_linux_debug_reg_state *
 837 arm_linux_get_debug_reg_state (pid_t pid)
 838 {
 839   return &arm_linux_process_info_get (pid)->state;
 840 }
 841
 842 /* Initialize an ARM hardware break-/watch-point control register value.
 843    BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
 844    type of break-/watch-point; ENABLE indicates whether the point is enabled.
 845    */
 846 static arm_hwbp_control_t
 847 arm_hwbp_control_initialize (unsigned byte_address_select,
 848                              arm_hwbp_type hwbp_type,
 849                              int enable)
 850 {
 851   gdb_assert ((byte_address_select & ~0xffU) == 0);
 852   gdb_assert (hwbp_type != arm_hwbp_break
 853               || ((byte_address_select & 0xfU) != 0));
 854
 855   return (byte_address_select << 5) | (hwbp_type << 3) | (3 << 1) | enable;
 856 }
 857
 858 /* Does the breakpoint control value CONTROL have the enable bit set?  */
 859 static int
 860 arm_hwbp_control_is_enabled (arm_hwbp_control_t control)
 861 {
 862   return control & 0x1;
 863 }
 864
 865 /* Change a breakpoint control word so that it is in the disabled state.  */
 866 static arm_hwbp_control_t
 867 arm_hwbp_control_disable (arm_hwbp_control_t control)
 868 {
 869   return control & ~0x1;
 870 }
 871
 872 /* Initialise the hardware breakpoint structure P.  The breakpoint will be
 873    enabled, and will point to the placed address of BP_TGT.  */
 874 static void
 875 arm_linux_hw_breakpoint_initialize (struct gdbarch *gdbarch,
 876                                     struct bp_target_info *bp_tgt,
 877                                     struct arm_linux_hw_breakpoint *p)
 878 {
 879   unsigned mask;
 880   CORE_ADDR address = bp_tgt->placed_address = bp_tgt->reqstd_address;
 881
 882   /* We have to create a mask for the control register which says which bits
 883      of the word pointed to by address to break on.  */
 884   if (arm_pc_is_thumb (gdbarch, address))
 885     {
 886       mask = 0x3;
 887       address &= ~1;
 888     }
 889   else
 890     {
 891       mask = 0xf;
 892       address &= ~3;
 893     }
 894
 895   p->address = (unsigned int) address;
 896   p->control = arm_hwbp_control_initialize (mask, arm_hwbp_break, 1);
 897 }
 898
 899 /* Get the ARM hardware breakpoint type from the TYPE value we're
 900    given when asked to set a watchpoint.  */
 901 static arm_hwbp_type
 902 arm_linux_get_hwbp_type (enum target_hw_bp_type type)
 903 {
 904   if (type == hw_read)
 905     return arm_hwbp_load;
 906   else if (type == hw_write)
 907     return arm_hwbp_store;
 908   else
 909     return arm_hwbp_access;
 910 }
 911
 912 /* Initialize the hardware breakpoint structure P for a watchpoint at ADDR
 913    to LEN.  The type of watchpoint is given in RW.  */
 914 static void
 915 arm_linux_hw_watchpoint_initialize (CORE_ADDR addr, int len,
 916                                     enum target_hw_bp_type type,
 917                                     struct arm_linux_hw_breakpoint *p)
 918 {
 919   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
 920   unsigned mask;
 921
 922   gdb_assert (cap != NULL);
 923   gdb_assert (cap->max_wp_length != 0);
 924
 925   mask = (1 << len) - 1;
 926
 927   p->address = (unsigned int) addr;
 928   p->control = arm_hwbp_control_initialize (mask,
 929                                             arm_linux_get_hwbp_type (type), 1);
 930 }
 931
 932 /* Are two break-/watch-points equal?  */
 933 static int
 934 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint *p1,
 935                                const struct arm_linux_hw_breakpoint *p2)
 936 {
 937   return p1->address == p2->address && p1->control == p2->control;
 938 }
 939
 940 /* Callback to mark a watch-/breakpoint to be updated in all threads of
 941    the current process.  */
 942
 943 static int
 944 update_registers_callback (struct lwp_info *lwp, int watch, int index)
 945 {
 946   if (lwp->arch_private == NULL)
 947     lwp->arch_private = XCNEW (struct arch_lwp_info);
 948
 949   /* The actual update is done later just before resuming the lwp,
 950      we just mark that the registers need updating.  */
 951   if (watch)
 952     lwp->arch_private->wpts_changed[index] = 1;
 953   else
 954     lwp->arch_private->bpts_changed[index] = 1;
 955
 956   /* If the lwp isn't stopped, force it to momentarily pause, so
 957      we can update its breakpoint registers.  */
 958   if (!lwp->stopped)
 959     linux_stop_lwp (lwp);
 960
 961   return 0;
 962 }
 963
 964 /* Insert the hardware breakpoint (WATCHPOINT = 0) or watchpoint (WATCHPOINT
 965    =1) BPT for thread TID.  */
 966 static void
 967 arm_linux_insert_hw_breakpoint1 (const struct arm_linux_hw_breakpoint* bpt,
 968                                  int watchpoint)
 969 {
 970   int pid;
 971   ptid_t pid_ptid;
 972   gdb_byte count, i;
 973   struct arm_linux_hw_breakpoint* bpts;
 974
 975   pid = inferior_ptid.pid ();
 976   pid_ptid = ptid_t (pid);
 977
 978   if (watchpoint)
 979     {
 980       count = arm_linux_get_hw_watchpoint_count ();
 981       bpts = arm_linux_get_debug_reg_state (pid)->wpts;
 982     }
 983   else
 984     {
 985       count = arm_linux_get_hw_breakpoint_count ();
 986       bpts = arm_linux_get_debug_reg_state (pid)->bpts;
 987     }
 988
 989   for (i = 0; i < count; ++i)
 990     if (!arm_hwbp_control_is_enabled (bpts[i].control))
 991       {
 992         bpts[i] = *bpt;
 993         iterate_over_lwps (pid_ptid,
 994                            [=] (struct lwp_info *info)
 995                            {
 996                              return update_registers_callback (info, watchpoint,
 997                                                                i);
 998                            });
 999         break;
1000       }
1001
1002   gdb_assert (i != count);
1003 }
1004
1005 /* Remove the hardware breakpoint (WATCHPOINT = 0) or watchpoint
1006    (WATCHPOINT = 1) BPT for thread TID.  */
1007 static void
1008 arm_linux_remove_hw_breakpoint1 (const struct arm_linux_hw_breakpoint *bpt,
1009                                  int watchpoint)
1010 {
1011   int pid;
1012   gdb_byte count, i;
1013   ptid_t pid_ptid;
1014   struct arm_linux_hw_breakpoint* bpts;
1015
1016   pid = inferior_ptid.pid ();
1017   pid_ptid = ptid_t (pid);
1018
1019   if (watchpoint)
1020     {
1021       count = arm_linux_get_hw_watchpoint_count ();
1022       bpts = arm_linux_get_debug_reg_state (pid)->wpts;
1023     }
1024   else
1025     {
1026       count = arm_linux_get_hw_breakpoint_count ();
1027       bpts = arm_linux_get_debug_reg_state (pid)->bpts;
1028     }
1029
1030   for (i = 0; i < count; ++i)
1031     if (arm_linux_hw_breakpoint_equal (bpt, bpts + i))
1032       {
1033         bpts[i].control = arm_hwbp_control_disable (bpts[i].control);
1034         iterate_over_lwps (pid_ptid,
1035                            [=] (struct lwp_info *info)
1036                            {
1037                              return update_registers_callback (info, watchpoint,
1038                                                                i);
1039                            });
1040         break;
1041       }
1042
1043   gdb_assert (i != count);
1044 }
1045
1046 /* Insert a Hardware breakpoint.  */
1047 int
1048 arm_linux_nat_target::insert_hw_breakpoint (struct gdbarch *gdbarch,
1049                                             struct bp_target_info *bp_tgt)
1050 {
1051   struct arm_linux_hw_breakpoint p;
1052
1053   if (arm_linux_get_hw_breakpoint_count () == 0)
1054     return -1;
1055
1056   arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p);
1057
1058   arm_linux_insert_hw_breakpoint1 (&p, 0);
1059
1060   return 0;
1061 }
1062
1063 /* Remove a hardware breakpoint.  */
1064 int
1065 arm_linux_nat_target::remove_hw_breakpoint (struct gdbarch *gdbarch,
1066                                             struct bp_target_info *bp_tgt)
1067 {
1068   struct arm_linux_hw_breakpoint p;
1069
1070   if (arm_linux_get_hw_breakpoint_count () == 0)
1071     return -1;
1072
1073   arm_linux_hw_breakpoint_initialize (gdbarch, bp_tgt, &p);
1074
1075   arm_linux_remove_hw_breakpoint1 (&p, 0);
1076
1077   return 0;
1078 }
1079
1080 /* Are we able to use a hardware watchpoint for the LEN bytes starting at
1081    ADDR?  */
1082 int
1083 arm_linux_nat_target::region_ok_for_hw_watchpoint (CORE_ADDR addr, int len)
1084 {
1085   const struct arm_linux_hwbp_cap *cap = arm_linux_get_hwbp_cap ();
1086   CORE_ADDR max_wp_length, aligned_addr;
1087
1088   /* Can not set watchpoints for zero or negative lengths.  */
1089   if (len <= 0)
1090     return 0;
1091
1092   /* Need to be able to use the ptrace interface.  */
1093   if (cap == NULL || cap->wp_count == 0)
1094     return 0;
1095
1096   /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
1097      range covered by a watchpoint.  */
1098   max_wp_length = (CORE_ADDR)cap->max_wp_length;
1099   aligned_addr = addr & ~(max_wp_length - 1);
1100
1101   if (aligned_addr + max_wp_length < addr + len)
1102     return 0;
1103
1104   /* The current ptrace interface can only handle watchpoints that are a
1105      power of 2.  */
1106   if ((len & (len - 1)) != 0)
1107     return 0;
1108
1109   /* All tests passed so we must be able to set a watchpoint.  */
1110   return 1;
1111 }
1112
1113 /* Insert a Hardware breakpoint.  */
1114 int
1115 arm_linux_nat_target::insert_watchpoint (CORE_ADDR addr, int len,
1116                                          enum target_hw_bp_type rw,
1117                                          struct expression *cond)
1118 {
1119   struct arm_linux_hw_breakpoint p;
1120
1121   if (arm_linux_get_hw_watchpoint_count () == 0)
1122     return -1;
1123
1124   arm_linux_hw_watchpoint_initialize (addr, len, rw, &p);
1125
1126   arm_linux_insert_hw_breakpoint1 (&p, 1);
1127
1128   return 0;
1129 }
1130
1131 /* Remove a hardware breakpoint.  */
1132 int
1133 arm_linux_nat_target::remove_watchpoint (CORE_ADDR addr,
1134                                          int len, enum target_hw_bp_type rw,
1135                                          struct expression *cond)
1136 {
1137   struct arm_linux_hw_breakpoint p;
1138
1139   if (arm_linux_get_hw_watchpoint_count () == 0)
1140     return -1;
1141
1142   arm_linux_hw_watchpoint_initialize (addr, len, rw, &p);
1143
1144   arm_linux_remove_hw_breakpoint1 (&p, 1);
1145
1146   return 0;
1147 }
1148
1149 /* What was the data address the target was stopped on accessing.  */
1150 bool
1151 arm_linux_nat_target::stopped_data_address (CORE_ADDR *addr_p)
1152 {
1153   siginfo_t siginfo;
1154   int slot;
1155
1156   if (!linux_nat_get_siginfo (inferior_ptid, &siginfo))
1157     return false;
1158
1159   /* This must be a hardware breakpoint.  */
1160   if (siginfo.si_signo != SIGTRAP
1161       || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
1162     return false;
1163
1164   /* We must be able to set hardware watchpoints.  */
1165   if (arm_linux_get_hw_watchpoint_count () == 0)
1166     return 0;
1167
1168   slot = siginfo.si_errno;
1169
1170   /* If we are in a positive slot then we're looking at a breakpoint and not
1171      a watchpoint.  */
1172   if (slot >= 0)
1173     return false;
1174
1175   *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr;
1176   return true;
1177 }
1178
1179 /* Has the target been stopped by hitting a watchpoint?  */
1180 bool
1181 arm_linux_nat_target::stopped_by_watchpoint ()
1182 {
1183   CORE_ADDR addr;
1184   return stopped_data_address (&addr);
1185 }
1186
1187 bool
1188 arm_linux_nat_target::watchpoint_addr_within_range (CORE_ADDR addr,
1189                                                     CORE_ADDR start,
1190                                                     int length)
1191 {
1192   return start <= addr && start + length - 1 >= addr;
1193 }
1194
1195 /* Handle thread creation.  We need to copy the breakpoints and watchpoints
1196    in the parent thread to the child thread.  */
1197 void
1198 arm_linux_nat_target::low_new_thread (struct lwp_info *lp)
1199 {
1200   int i;
1201   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
1202
1203   /* Mark that all the hardware breakpoint/watchpoint register pairs
1204      for this thread need to be initialized.  */
1205
1206   for (i = 0; i < MAX_BPTS; i++)
1207     {
1208       info->bpts_changed[i] = 1;
1209       info->wpts_changed[i] = 1;
1210     }
1211
1212   lp->arch_private = info;
1213 }
1214
1215 /* Function to call when a thread is being deleted.  */
1216
1217 void
1218 arm_linux_nat_target::low_delete_thread (struct arch_lwp_info *arch_lwp)
1219 {
1220   xfree (arch_lwp);
1221 }
1222
1223 /* Called when resuming a thread.
1224    The hardware debug registers are updated when there is any change.  */
1225
1226 void
1227 arm_linux_nat_target::low_prepare_to_resume (struct lwp_info *lwp)
1228 {
1229   int pid, i;
1230   struct arm_linux_hw_breakpoint *bpts, *wpts;
1231   struct arch_lwp_info *arm_lwp_info = lwp->arch_private;
1232
1233   pid = lwp->ptid.lwp ();
1234   bpts = arm_linux_get_debug_reg_state (lwp->ptid.pid ())->bpts;
1235   wpts = arm_linux_get_debug_reg_state (lwp->ptid.pid ())->wpts;
1236
1237   /* NULL means this is the main thread still going through the shell,
1238      or, no watchpoint has been set yet.  In that case, there's
1239      nothing to do.  */
1240   if (arm_lwp_info == NULL)
1241     return;
1242
1243   for (i = 0; i < arm_linux_get_hw_breakpoint_count (); i++)
1244     if (arm_lwp_info->bpts_changed[i])
1245       {
1246         errno = 0;
1247         if (arm_hwbp_control_is_enabled (bpts[i].control))
1248           if (ptrace (PTRACE_SETHBPREGS, pid,
1249               (PTRACE_TYPE_ARG3) ((i << 1) + 1), &bpts[i].address) < 0)
1250             perror_with_name (_("Unexpected error setting breakpoint"));
1251
1252         if (bpts[i].control != 0)
1253           if (ptrace (PTRACE_SETHBPREGS, pid,
1254               (PTRACE_TYPE_ARG3) ((i << 1) + 2), &bpts[i].control) < 0)
1255             perror_with_name (_("Unexpected error setting breakpoint"));
1256
1257         arm_lwp_info->bpts_changed[i] = 0;
1258       }
1259
1260   for (i = 0; i < arm_linux_get_hw_watchpoint_count (); i++)
1261     if (arm_lwp_info->wpts_changed[i])
1262       {
1263         errno = 0;
1264         if (arm_hwbp_control_is_enabled (wpts[i].control))
1265           if (ptrace (PTRACE_SETHBPREGS, pid,
1266               (PTRACE_TYPE_ARG3) -((i << 1) + 1), &wpts[i].address) < 0)
1267             perror_with_name (_("Unexpected error setting watchpoint"));
1268
1269         if (wpts[i].control != 0)
1270           if (ptrace (PTRACE_SETHBPREGS, pid,
1271               (PTRACE_TYPE_ARG3) -((i << 1) + 2), &wpts[i].control) < 0)
1272             perror_with_name (_("Unexpected error setting watchpoint"));
1273
1274         arm_lwp_info->wpts_changed[i] = 0;
1275       }
1276 }
1277
1278 /* linux_nat_new_fork hook.  */
1279
1280 void
1281 arm_linux_nat_target::low_new_fork (struct lwp_info *parent, pid_t child_pid)
1282 {
1283   pid_t parent_pid;
1284   struct arm_linux_debug_reg_state *parent_state;
1285   struct arm_linux_debug_reg_state *child_state;
1286
1287   /* NULL means no watchpoint has ever been set in the parent.  In
1288      that case, there's nothing to do.  */
1289   if (parent->arch_private == NULL)
1290     return;
1291
1292   /* GDB core assumes the child inherits the watchpoints/hw
1293      breakpoints of the parent, and will remove them all from the
1294      forked off process.  Copy the debug registers mirrors into the
1295      new process so that all breakpoints and watchpoints can be
1296      removed together.  */
1297
1298   parent_pid = parent->ptid.pid ();
1299   parent_state = arm_linux_get_debug_reg_state (parent_pid);
1300   child_state = arm_linux_get_debug_reg_state (child_pid);
1301   *child_state = *parent_state;
1302 }
1303
1304 void
1305 _initialize_arm_linux_nat (void)
1306 {
1307   /* Register the target.  */
1308   linux_target = &the_arm_linux_nat_target;
1309   add_inf_child_target (&the_arm_linux_nat_target);
1310 }