gdb/gdbserver/linux-arm-low.c

   1 /* GNU/Linux/ARM specific low level interface, for the remote server for GDB.
   2    Copyright (C) 1995-2016 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 "server.h"
  20 #include "linux-low.h"
  21 #include "arch/arm.h"
  22 #include "arch/arm-linux.h"
  23 #include "arch/arm-get-next-pcs.h"
  24 #include "linux-aarch32-low.h"
  25
  26 #include <sys/uio.h>
  27 /* Don't include elf.h if linux/elf.h got included by gdb_proc_service.h.
  28    On Bionic elf.h and linux/elf.h have conflicting definitions.  */
  29 #ifndef ELFMAG0
  30 #include <elf.h>
  31 #endif
  32 #include "nat/gdb_ptrace.h"
  33 #include <signal.h>
  34 #include <sys/syscall.h>
  35
  36 /* Defined in auto-generated files.  */
  37 void init_registers_arm (void);
  38 extern const struct target_desc *tdesc_arm;
  39
  40 void init_registers_arm_with_iwmmxt (void);
  41 extern const struct target_desc *tdesc_arm_with_iwmmxt;
  42
  43 void init_registers_arm_with_vfpv2 (void);
  44 extern const struct target_desc *tdesc_arm_with_vfpv2;
  45
  46 void init_registers_arm_with_vfpv3 (void);
  47 extern const struct target_desc *tdesc_arm_with_vfpv3;
  48
  49 #ifndef PTRACE_GET_THREAD_AREA
  50 #define PTRACE_GET_THREAD_AREA 22
  51 #endif
  52
  53 #ifndef PTRACE_GETWMMXREGS
  54 # define PTRACE_GETWMMXREGS 18
  55 # define PTRACE_SETWMMXREGS 19
  56 #endif
  57
  58 #ifndef PTRACE_GETVFPREGS
  59 # define PTRACE_GETVFPREGS 27
  60 # define PTRACE_SETVFPREGS 28
  61 #endif
  62
  63 #ifndef PTRACE_GETHBPREGS
  64 #define PTRACE_GETHBPREGS 29
  65 #define PTRACE_SETHBPREGS 30
  66 #endif
  67
  68 /* Information describing the hardware breakpoint capabilities.  */
  69 static struct
  70 {
  71   unsigned char arch;
  72   unsigned char max_wp_length;
  73   unsigned char wp_count;
  74   unsigned char bp_count;
  75 } arm_linux_hwbp_cap;
  76
  77 /* Enum describing the different types of ARM hardware break-/watch-points.  */
  78 typedef enum
  79 {
  80   arm_hwbp_break = 0,
  81   arm_hwbp_load = 1,
  82   arm_hwbp_store = 2,
  83   arm_hwbp_access = 3
  84 } arm_hwbp_type;
  85
  86 /* Type describing an ARM Hardware Breakpoint Control register value.  */
  87 typedef unsigned int arm_hwbp_control_t;
  88
  89 /* Structure used to keep track of hardware break-/watch-points.  */
  90 struct arm_linux_hw_breakpoint
  91 {
  92   /* Address to break on, or being watched.  */
  93   unsigned int address;
  94   /* Control register for break-/watch- point.  */
  95   arm_hwbp_control_t control;
  96 };
  97
  98 /* Since we cannot dynamically allocate subfields of arch_process_info,
  99    assume a maximum number of supported break-/watchpoints.  */
 100 #define MAX_BPTS 32
 101 #define MAX_WPTS 32
 102
 103 /* Per-process arch-specific data we want to keep.  */
 104 struct arch_process_info
 105 {
 106   /* Hardware breakpoints for this process.  */
 107   struct arm_linux_hw_breakpoint bpts[MAX_BPTS];
 108   /* Hardware watchpoints for this process.  */
 109   struct arm_linux_hw_breakpoint wpts[MAX_WPTS];
 110 };
 111
 112 /* Per-thread arch-specific data we want to keep.  */
 113 struct arch_lwp_info
 114 {
 115   /* Non-zero if our copy differs from what's recorded in the thread.  */
 116   char bpts_changed[MAX_BPTS];
 117   char wpts_changed[MAX_WPTS];
 118   /* Cached stopped data address.  */
 119   CORE_ADDR stopped_data_address;
 120 };
 121
 122 /* These are in <asm/elf.h> in current kernels.  */
 123 #define HWCAP_VFP       64
 124 #define HWCAP_IWMMXT    512
 125 #define HWCAP_NEON      4096
 126 #define HWCAP_VFPv3     8192
 127 #define HWCAP_VFPv3D16  16384
 128
 129 #ifdef HAVE_SYS_REG_H
 130 #include <sys/reg.h>
 131 #endif
 132
 133 #define arm_num_regs 26
 134
 135 static int arm_regmap[] = {
 136   0, 4, 8, 12, 16, 20, 24, 28,
 137   32, 36, 40, 44, 48, 52, 56, 60,
 138   -1, -1, -1, -1, -1, -1, -1, -1, -1,
 139   64
 140 };
 141
 142 /* Forward declarations needed for get_next_pcs ops.  */
 143 static ULONGEST get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr,
 144                                                            int len,
 145                                                            int byte_order);
 146
 147 static CORE_ADDR get_next_pcs_addr_bits_remove (struct arm_get_next_pcs *self,
 148                                                 CORE_ADDR val);
 149
 150 static CORE_ADDR get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self,
 151                                                CORE_ADDR pc);
 152
 153 static int get_next_pcs_is_thumb (struct arm_get_next_pcs *self);
 154
 155 /* get_next_pcs operations.  */
 156 static struct arm_get_next_pcs_ops get_next_pcs_ops = {
 157   get_next_pcs_read_memory_unsigned_integer,
 158   get_next_pcs_syscall_next_pc,
 159   get_next_pcs_addr_bits_remove,
 160   get_next_pcs_is_thumb
 161 };
 162
 163 static int
 164 arm_cannot_store_register (int regno)
 165 {
 166   return (regno >= arm_num_regs);
 167 }
 168
 169 static int
 170 arm_cannot_fetch_register (int regno)
 171 {
 172   return (regno >= arm_num_regs);
 173 }
 174
 175 static void
 176 arm_fill_wmmxregset (struct regcache *regcache, void *buf)
 177 {
 178   int i;
 179
 180   if (regcache->tdesc != tdesc_arm_with_iwmmxt)
 181     return;
 182
 183   for (i = 0; i < 16; i++)
 184     collect_register (regcache, arm_num_regs + i, (char *) buf + i * 8);
 185
 186   /* We only have access to wcssf, wcasf, and wcgr0-wcgr3.  */
 187   for (i = 0; i < 6; i++)
 188     collect_register (regcache, arm_num_regs + i + 16,
 189                       (char *) buf + 16 * 8 + i * 4);
 190 }
 191
 192 static void
 193 arm_store_wmmxregset (struct regcache *regcache, const void *buf)
 194 {
 195   int i;
 196
 197   if (regcache->tdesc != tdesc_arm_with_iwmmxt)
 198     return;
 199
 200   for (i = 0; i < 16; i++)
 201     supply_register (regcache, arm_num_regs + i, (char *) buf + i * 8);
 202
 203   /* We only have access to wcssf, wcasf, and wcgr0-wcgr3.  */
 204   for (i = 0; i < 6; i++)
 205     supply_register (regcache, arm_num_regs + i + 16,
 206                      (char *) buf + 16 * 8 + i * 4);
 207 }
 208
 209 static void
 210 arm_fill_vfpregset (struct regcache *regcache, void *buf)
 211 {
 212   int num;
 213
 214   if (regcache->tdesc == tdesc_arm_with_neon
 215       || regcache->tdesc == tdesc_arm_with_vfpv3)
 216     num = 32;
 217   else if (regcache->tdesc == tdesc_arm_with_vfpv2)
 218     num = 16;
 219   else
 220     return;
 221
 222   arm_fill_vfpregset_num (regcache, buf, num);
 223 }
 224
 225 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs.  */
 226 static CORE_ADDR
 227 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs *self, CORE_ADDR val)
 228 {
 229   return UNMAKE_THUMB_ADDR (val);
 230 }
 231
 232 static void
 233 arm_store_vfpregset (struct regcache *regcache, const void *buf)
 234 {
 235   int num;
 236
 237   if (regcache->tdesc == tdesc_arm_with_neon
 238       || regcache->tdesc == tdesc_arm_with_vfpv3)
 239     num = 32;
 240   else if (regcache->tdesc == tdesc_arm_with_vfpv2)
 241     num = 16;
 242   else
 243     return;
 244
 245   arm_store_vfpregset_num (regcache, buf, num);
 246 }
 247
 248 extern int debug_threads;
 249
 250 static CORE_ADDR
 251 arm_get_pc (struct regcache *regcache)
 252 {
 253   unsigned long pc;
 254   collect_register_by_name (regcache, "pc", &pc);
 255   if (debug_threads)
 256     debug_printf ("stop pc is %08lx\n", pc);
 257   return pc;
 258 }
 259
 260 static void
 261 arm_set_pc (struct regcache *regcache, CORE_ADDR pc)
 262 {
 263   unsigned long newpc = pc;
 264   supply_register_by_name (regcache, "pc", &newpc);
 265 }
 266
 267 /* Wrapper of arm_is_thumb_mode for get_next_pcs.  */
 268 static int
 269 get_next_pcs_is_thumb (struct arm_get_next_pcs *self)
 270 {
 271   return arm_is_thumb_mode ();
 272 }
 273
 274 /* Read memory from the inferiror.
 275    BYTE_ORDER is ignored and there to keep compatiblity with GDB's
 276    read_memory_unsigned_integer. */
 277 static ULONGEST
 278 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr,
 279                                            int len,
 280                                            int byte_order)
 281 {
 282   ULONGEST res;
 283
 284   (*the_target->read_memory) (memaddr, (unsigned char *) &res, len);
 285   return res;
 286 }
 287
 288 /* Fetch the thread-local storage pointer for libthread_db.  */
 289
 290 ps_err_e
 291 ps_get_thread_area (const struct ps_prochandle *ph,
 292                     lwpid_t lwpid, int idx, void **base)
 293 {
 294   if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
 295     return PS_ERR;
 296
 297   /* IDX is the bias from the thread pointer to the beginning of the
 298      thread descriptor.  It has to be subtracted due to implementation
 299      quirks in libthread_db.  */
 300   *base = (void *) ((char *)*base - idx);
 301
 302   return PS_OK;
 303 }
 304
 305
 306 /* Query Hardware Breakpoint information for the target we are attached to
 307    (using PID as ptrace argument) and set up arm_linux_hwbp_cap.  */
 308 static void
 309 arm_linux_init_hwbp_cap (int pid)
 310 {
 311   unsigned int val;
 312
 313   if (ptrace (PTRACE_GETHBPREGS, pid, 0, &val) < 0)
 314     return;
 315
 316   arm_linux_hwbp_cap.arch = (unsigned char)((val >> 24) & 0xff);
 317   if (arm_linux_hwbp_cap.arch == 0)
 318     return;
 319
 320   arm_linux_hwbp_cap.max_wp_length = (unsigned char)((val >> 16) & 0xff);
 321   arm_linux_hwbp_cap.wp_count = (unsigned char)((val >> 8) & 0xff);
 322   arm_linux_hwbp_cap.bp_count = (unsigned char)(val & 0xff);
 323
 324   if (arm_linux_hwbp_cap.wp_count > MAX_WPTS)
 325     internal_error (__FILE__, __LINE__, "Unsupported number of watchpoints");
 326   if (arm_linux_hwbp_cap.bp_count > MAX_BPTS)
 327     internal_error (__FILE__, __LINE__, "Unsupported number of breakpoints");
 328 }
 329
 330 /* How many hardware breakpoints are available?  */
 331 static int
 332 arm_linux_get_hw_breakpoint_count (void)
 333 {
 334   return arm_linux_hwbp_cap.bp_count;
 335 }
 336
 337 /* How many hardware watchpoints are available?  */
 338 static int
 339 arm_linux_get_hw_watchpoint_count (void)
 340 {
 341   return arm_linux_hwbp_cap.wp_count;
 342 }
 343
 344 /* Maximum length of area watched by hardware watchpoint.  */
 345 static int
 346 arm_linux_get_hw_watchpoint_max_length (void)
 347 {
 348   return arm_linux_hwbp_cap.max_wp_length;
 349 }
 350
 351 /* Initialize an ARM hardware break-/watch-point control register value.
 352    BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
 353    type of break-/watch-point; ENABLE indicates whether the point is enabled.
 354    */
 355 static arm_hwbp_control_t
 356 arm_hwbp_control_initialize (unsigned byte_address_select,
 357                              arm_hwbp_type hwbp_type,
 358                              int enable)
 359 {
 360   gdb_assert ((byte_address_select & ~0xffU) == 0);
 361   gdb_assert (hwbp_type != arm_hwbp_break
 362               || ((byte_address_select & 0xfU) != 0));
 363
 364   return (byte_address_select << 5) | (hwbp_type << 3) | (3 << 1) | enable;
 365 }
 366
 367 /* Does the breakpoint control value CONTROL have the enable bit set?  */
 368 static int
 369 arm_hwbp_control_is_enabled (arm_hwbp_control_t control)
 370 {
 371   return control & 0x1;
 372 }
 373
 374 /* Is the breakpoint control value CONTROL initialized?  */
 375 static int
 376 arm_hwbp_control_is_initialized (arm_hwbp_control_t control)
 377 {
 378   return control != 0;
 379 }
 380
 381 /* Change a breakpoint control word so that it is in the disabled state.  */
 382 static arm_hwbp_control_t
 383 arm_hwbp_control_disable (arm_hwbp_control_t control)
 384 {
 385   return control & ~0x1;
 386 }
 387
 388 /* Are two break-/watch-points equal?  */
 389 static int
 390 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint *p1,
 391                                const struct arm_linux_hw_breakpoint *p2)
 392 {
 393   return p1->address == p2->address && p1->control == p2->control;
 394 }
 395
 396 /* Convert a raw breakpoint type to an enum arm_hwbp_type.  */
 397
 398 static arm_hwbp_type
 399 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type)
 400 {
 401   switch (raw_type)
 402     {
 403     case raw_bkpt_type_hw:
 404       return arm_hwbp_break;
 405     case raw_bkpt_type_write_wp:
 406       return arm_hwbp_store;
 407     case raw_bkpt_type_read_wp:
 408       return arm_hwbp_load;
 409     case raw_bkpt_type_access_wp:
 410       return arm_hwbp_access;
 411     default:
 412       gdb_assert_not_reached ("unhandled raw type");
 413     }
 414 }
 415
 416 /* Initialize the hardware breakpoint structure P for a breakpoint or
 417    watchpoint at ADDR to LEN.  The type of watchpoint is given in TYPE.
 418    Returns -1 if TYPE is unsupported, or -2 if the particular combination
 419    of ADDR and LEN cannot be implemented.  Otherwise, returns 0 if TYPE
 420    represents a breakpoint and 1 if type represents a watchpoint.  */
 421 static int
 422 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type, CORE_ADDR addr,
 423                                int len, struct arm_linux_hw_breakpoint *p)
 424 {
 425   arm_hwbp_type hwbp_type;
 426   unsigned mask;
 427
 428   hwbp_type = raw_bkpt_type_to_arm_hwbp_type (raw_type);
 429
 430   if (hwbp_type == arm_hwbp_break)
 431     {
 432       /* For breakpoints, the length field encodes the mode.  */
 433       switch (len)
 434         {
 435         case 2:  /* 16-bit Thumb mode breakpoint */
 436         case 3:  /* 32-bit Thumb mode breakpoint */
 437           mask = 0x3;
 438           addr &= ~1;
 439           break;
 440         case 4:  /* 32-bit ARM mode breakpoint */
 441           mask = 0xf;
 442           addr &= ~3;
 443           break;
 444         default:
 445           /* Unsupported. */
 446           return -2;
 447         }
 448     }
 449   else
 450     {
 451       CORE_ADDR max_wp_length = arm_linux_get_hw_watchpoint_max_length ();
 452       CORE_ADDR aligned_addr;
 453
 454       /* Can not set watchpoints for zero or negative lengths.  */
 455       if (len <= 0)
 456         return -2;
 457       /* The current ptrace interface can only handle watchpoints that are a
 458          power of 2.  */
 459       if ((len & (len - 1)) != 0)
 460         return -2;
 461
 462       /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
 463          range covered by a watchpoint.  */
 464       aligned_addr = addr & ~(max_wp_length - 1);
 465       if (aligned_addr + max_wp_length < addr + len)
 466         return -2;
 467
 468       mask = (1 << len) - 1;
 469     }
 470
 471   p->address = (unsigned int) addr;
 472   p->control = arm_hwbp_control_initialize (mask, hwbp_type, 1);
 473
 474   return hwbp_type != arm_hwbp_break;
 475 }
 476
 477 /* Callback to mark a watch-/breakpoint to be updated in all threads of
 478    the current process.  */
 479
 480 struct update_registers_data
 481 {
 482   int watch;
 483   int i;
 484 };
 485
 486 static int
 487 update_registers_callback (struct inferior_list_entry *entry, void *arg)
 488 {
 489   struct thread_info *thread = (struct thread_info *) entry;
 490   struct lwp_info *lwp = get_thread_lwp (thread);
 491   struct update_registers_data *data = (struct update_registers_data *) arg;
 492
 493   /* Only update the threads of the current process.  */
 494   if (pid_of (thread) == pid_of (current_thread))
 495     {
 496       /* The actual update is done later just before resuming the lwp,
 497          we just mark that the registers need updating.  */
 498       if (data->watch)
 499         lwp->arch_private->wpts_changed[data->i] = 1;
 500       else
 501         lwp->arch_private->bpts_changed[data->i] = 1;
 502
 503       /* If the lwp isn't stopped, force it to momentarily pause, so
 504          we can update its breakpoint registers.  */
 505       if (!lwp->stopped)
 506         linux_stop_lwp (lwp);
 507     }
 508
 509   return 0;
 510 }
 511
 512 static int
 513 arm_supports_z_point_type (char z_type)
 514 {
 515   switch (z_type)
 516     {
 517     case Z_PACKET_SW_BP:
 518     case Z_PACKET_HW_BP:
 519     case Z_PACKET_WRITE_WP:
 520     case Z_PACKET_READ_WP:
 521     case Z_PACKET_ACCESS_WP:
 522       return 1;
 523     default:
 524       /* Leave the handling of sw breakpoints with the gdb client.  */
 525       return 0;
 526     }
 527 }
 528
 529 /* Insert hardware break-/watchpoint.  */
 530 static int
 531 arm_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
 532                   int len, struct raw_breakpoint *bp)
 533 {
 534   struct process_info *proc = current_process ();
 535   struct arm_linux_hw_breakpoint p, *pts;
 536   int watch, i, count;
 537
 538   watch = arm_linux_hw_point_initialize (type, addr, len, &p);
 539   if (watch < 0)
 540     {
 541       /* Unsupported.  */
 542       return watch == -1 ? 1 : -1;
 543     }
 544
 545   if (watch)
 546     {
 547       count = arm_linux_get_hw_watchpoint_count ();
 548       pts = proc->priv->arch_private->wpts;
 549     }
 550   else
 551     {
 552       count = arm_linux_get_hw_breakpoint_count ();
 553       pts = proc->priv->arch_private->bpts;
 554     }
 555
 556   for (i = 0; i < count; i++)
 557     if (!arm_hwbp_control_is_enabled (pts[i].control))
 558       {
 559         struct update_registers_data data = { watch, i };
 560         pts[i] = p;
 561         find_inferior (&all_threads, update_registers_callback, &data);
 562         return 0;
 563       }
 564
 565   /* We're out of watchpoints.  */
 566   return -1;
 567 }
 568
 569 /* Remove hardware break-/watchpoint.  */
 570 static int
 571 arm_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
 572                   int len, struct raw_breakpoint *bp)
 573 {
 574   struct process_info *proc = current_process ();
 575   struct arm_linux_hw_breakpoint p, *pts;
 576   int watch, i, count;
 577
 578   watch = arm_linux_hw_point_initialize (type, addr, len, &p);
 579   if (watch < 0)
 580     {
 581       /* Unsupported.  */
 582       return -1;
 583     }
 584
 585   if (watch)
 586     {
 587       count = arm_linux_get_hw_watchpoint_count ();
 588       pts = proc->priv->arch_private->wpts;
 589     }
 590   else
 591     {
 592       count = arm_linux_get_hw_breakpoint_count ();
 593       pts = proc->priv->arch_private->bpts;
 594     }
 595
 596   for (i = 0; i < count; i++)
 597     if (arm_linux_hw_breakpoint_equal (&p, pts + i))
 598       {
 599         struct update_registers_data data = { watch, i };
 600         pts[i].control = arm_hwbp_control_disable (pts[i].control);
 601         find_inferior (&all_threads, update_registers_callback, &data);
 602         return 0;
 603       }
 604
 605   /* No watchpoint matched.  */
 606   return -1;
 607 }
 608
 609 /* Return whether current thread is stopped due to a watchpoint.  */
 610 static int
 611 arm_stopped_by_watchpoint (void)
 612 {
 613   struct lwp_info *lwp = get_thread_lwp (current_thread);
 614   siginfo_t siginfo;
 615
 616   /* We must be able to set hardware watchpoints.  */
 617   if (arm_linux_get_hw_watchpoint_count () == 0)
 618     return 0;
 619
 620   /* Retrieve siginfo.  */
 621   errno = 0;
 622   ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread), 0, &siginfo);
 623   if (errno != 0)
 624     return 0;
 625
 626   /* This must be a hardware breakpoint.  */
 627   if (siginfo.si_signo != SIGTRAP
 628       || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
 629     return 0;
 630
 631   /* If we are in a positive slot then we're looking at a breakpoint and not
 632      a watchpoint.  */
 633   if (siginfo.si_errno >= 0)
 634     return 0;
 635
 636   /* Cache stopped data address for use by arm_stopped_data_address.  */
 637   lwp->arch_private->stopped_data_address
 638     = (CORE_ADDR) (uintptr_t) siginfo.si_addr;
 639
 640   return 1;
 641 }
 642
 643 /* Return data address that triggered watchpoint.  Called only if
 644    arm_stopped_by_watchpoint returned true.  */
 645 static CORE_ADDR
 646 arm_stopped_data_address (void)
 647 {
 648   struct lwp_info *lwp = get_thread_lwp (current_thread);
 649   return lwp->arch_private->stopped_data_address;
 650 }
 651
 652 /* Called when a new process is created.  */
 653 static struct arch_process_info *
 654 arm_new_process (void)
 655 {
 656   struct arch_process_info *info = XCNEW (struct arch_process_info);
 657   return info;
 658 }
 659
 660 /* Called when a new thread is detected.  */
 661 static void
 662 arm_new_thread (struct lwp_info *lwp)
 663 {
 664   struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
 665   int i;
 666
 667   for (i = 0; i < MAX_BPTS; i++)
 668     info->bpts_changed[i] = 1;
 669   for (i = 0; i < MAX_WPTS; i++)
 670     info->wpts_changed[i] = 1;
 671
 672   lwp->arch_private = info;
 673 }
 674
 675 static void
 676 arm_new_fork (struct process_info *parent, struct process_info *child)
 677 {
 678   struct arch_process_info *parent_proc_info;
 679   struct arch_process_info *child_proc_info;
 680   struct lwp_info *child_lwp;
 681   struct arch_lwp_info *child_lwp_info;
 682   int i;
 683
 684   /* These are allocated by linux_add_process.  */
 685   gdb_assert (parent->priv != NULL
 686               && parent->priv->arch_private != NULL);
 687   gdb_assert (child->priv != NULL
 688               && child->priv->arch_private != NULL);
 689
 690   parent_proc_info = parent->priv->arch_private;
 691   child_proc_info = child->priv->arch_private;
 692
 693   /* Linux kernel before 2.6.33 commit
 694      72f674d203cd230426437cdcf7dd6f681dad8b0d
 695      will inherit hardware debug registers from parent
 696      on fork/vfork/clone.  Newer Linux kernels create such tasks with
 697      zeroed debug registers.
 698
 699      GDB core assumes the child inherits the watchpoints/hw
 700      breakpoints of the parent, and will remove them all from the
 701      forked off process.  Copy the debug registers mirrors into the
 702      new process so that all breakpoints and watchpoints can be
 703      removed together.  The debug registers mirror will become zeroed
 704      in the end before detaching the forked off process, thus making
 705      this compatible with older Linux kernels too.  */
 706
 707   *child_proc_info = *parent_proc_info;
 708
 709   /* Mark all the hardware breakpoints and watchpoints as changed to
 710      make sure that the registers will be updated.  */
 711   child_lwp = find_lwp_pid (ptid_of (child));
 712   child_lwp_info = child_lwp->arch_private;
 713   for (i = 0; i < MAX_BPTS; i++)
 714     child_lwp_info->bpts_changed[i] = 1;
 715   for (i = 0; i < MAX_WPTS; i++)
 716     child_lwp_info->wpts_changed[i] = 1;
 717 }
 718
 719 /* Called when resuming a thread.
 720    If the debug regs have changed, update the thread's copies.  */
 721 static void
 722 arm_prepare_to_resume (struct lwp_info *lwp)
 723 {
 724   struct thread_info *thread = get_lwp_thread (lwp);
 725   int pid = lwpid_of (thread);
 726   struct process_info *proc = find_process_pid (pid_of (thread));
 727   struct arch_process_info *proc_info = proc->priv->arch_private;
 728   struct arch_lwp_info *lwp_info = lwp->arch_private;
 729   int i;
 730
 731   for (i = 0; i < arm_linux_get_hw_breakpoint_count (); i++)
 732     if (lwp_info->bpts_changed[i])
 733       {
 734         errno = 0;
 735
 736         if (arm_hwbp_control_is_enabled (proc_info->bpts[i].control))
 737           if (ptrace (PTRACE_SETHBPREGS, pid,
 738                       (PTRACE_TYPE_ARG3) ((i << 1) + 1),
 739                       &proc_info->bpts[i].address) < 0)
 740             perror_with_name ("Unexpected error setting breakpoint address");
 741
 742         if (arm_hwbp_control_is_initialized (proc_info->bpts[i].control))
 743           if (ptrace (PTRACE_SETHBPREGS, pid,
 744                       (PTRACE_TYPE_ARG3) ((i << 1) + 2),
 745                       &proc_info->bpts[i].control) < 0)
 746             perror_with_name ("Unexpected error setting breakpoint");
 747
 748         lwp_info->bpts_changed[i] = 0;
 749       }
 750
 751   for (i = 0; i < arm_linux_get_hw_watchpoint_count (); i++)
 752     if (lwp_info->wpts_changed[i])
 753       {
 754         errno = 0;
 755
 756         if (arm_hwbp_control_is_enabled (proc_info->wpts[i].control))
 757           if (ptrace (PTRACE_SETHBPREGS, pid,
 758                       (PTRACE_TYPE_ARG3) -((i << 1) + 1),
 759                       &proc_info->wpts[i].address) < 0)
 760             perror_with_name ("Unexpected error setting watchpoint address");
 761
 762         if (arm_hwbp_control_is_initialized (proc_info->wpts[i].control))
 763           if (ptrace (PTRACE_SETHBPREGS, pid,
 764                       (PTRACE_TYPE_ARG3) -((i << 1) + 2),
 765                       &proc_info->wpts[i].control) < 0)
 766             perror_with_name ("Unexpected error setting watchpoint");
 767
 768         lwp_info->wpts_changed[i] = 0;
 769       }
 770 }
 771
 772 /* Find the next pc for a sigreturn or rt_sigreturn syscall.
 773    See arm-linux.h for stack layout details.  */
 774 static CORE_ADDR
 775 arm_sigreturn_next_pc (struct regcache *regcache, int svc_number)
 776 {
 777   unsigned long sp;
 778   unsigned long sp_data;
 779   /* Offset of PC register.  */
 780   int pc_offset = 0;
 781   CORE_ADDR next_pc = 0;
 782
 783   gdb_assert (svc_number == __NR_sigreturn || svc_number == __NR_rt_sigreturn);
 784
 785   collect_register_by_name (regcache, "sp", &sp);
 786   (*the_target->read_memory) (sp, (unsigned char *) &sp_data, 4);
 787
 788   pc_offset = arm_linux_sigreturn_next_pc_offset
 789     (sp, sp_data, svc_number, __NR_sigreturn == svc_number ? 1 : 0);
 790
 791   (*the_target->read_memory) (sp + pc_offset, (unsigned char *) &next_pc, 4);
 792
 793   return next_pc;
 794 }
 795
 796 /* When PC is at a syscall instruction, return the PC of the next
 797    instruction to be executed.  */
 798 static CORE_ADDR
 799 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self, CORE_ADDR pc)
 800 {
 801   CORE_ADDR next_pc = 0;
 802   int is_thumb = arm_is_thumb_mode ();
 803   ULONGEST svc_number = 0;
 804   struct regcache *regcache = self->regcache;
 805
 806   if (is_thumb)
 807     {
 808       collect_register (regcache, 7, &svc_number);
 809       next_pc = pc + 2;
 810     }
 811   else
 812     {
 813       unsigned long this_instr;
 814       unsigned long svc_operand;
 815
 816       (*the_target->read_memory) (pc, (unsigned char *) &this_instr, 4);
 817       svc_operand = (0x00ffffff & this_instr);
 818
 819       if (svc_operand)  /* OABI.  */
 820         {
 821           svc_number = svc_operand - 0x900000;
 822         }
 823       else /* EABI.  */
 824         {
 825           collect_register (regcache, 7, &svc_number);
 826         }
 827
 828       next_pc = pc + 4;
 829     }
 830
 831   /* This is a sigreturn or sigreturn_rt syscall.  */
 832   if (svc_number == __NR_sigreturn || svc_number == __NR_rt_sigreturn)
 833     {
 834       next_pc = arm_sigreturn_next_pc (regcache, svc_number);
 835     }
 836
 837   /* Addresses for calling Thumb functions have the bit 0 set.  */
 838   if (is_thumb)
 839     next_pc = MAKE_THUMB_ADDR (next_pc);
 840
 841   return next_pc;
 842 }
 843
 844 static int
 845 arm_get_hwcap (unsigned long *valp)
 846 {
 847   unsigned char *data = (unsigned char *) alloca (8);
 848   int offset = 0;
 849
 850   while ((*the_target->read_auxv) (offset, data, 8) == 8)
 851     {
 852       unsigned int *data_p = (unsigned int *)data;
 853       if (data_p[0] == AT_HWCAP)
 854         {
 855           *valp = data_p[1];
 856           return 1;
 857         }
 858
 859       offset += 8;
 860     }
 861
 862   *valp = 0;
 863   return 0;
 864 }
 865
 866 static const struct target_desc *
 867 arm_read_description (void)
 868 {
 869   int pid = lwpid_of (current_thread);
 870   unsigned long arm_hwcap = 0;
 871
 872   /* Query hardware watchpoint/breakpoint capabilities.  */
 873   arm_linux_init_hwbp_cap (pid);
 874
 875   if (arm_get_hwcap (&arm_hwcap) == 0)
 876     return tdesc_arm;
 877
 878   if (arm_hwcap & HWCAP_IWMMXT)
 879     return tdesc_arm_with_iwmmxt;
 880
 881   if (arm_hwcap & HWCAP_VFP)
 882     {
 883       const struct target_desc *result;
 884       char *buf;
 885
 886       /* NEON implies either no VFP, or VFPv3-D32.  We only support
 887          it with VFP.  */
 888       if (arm_hwcap & HWCAP_NEON)
 889         result = tdesc_arm_with_neon;
 890       else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
 891         result = tdesc_arm_with_vfpv3;
 892       else
 893         result = tdesc_arm_with_vfpv2;
 894
 895       /* Now make sure that the kernel supports reading these
 896          registers.  Support was added in 2.6.30.  */
 897       errno = 0;
 898       buf = (char *) xmalloc (32 * 8 + 4);
 899       if (ptrace (PTRACE_GETVFPREGS, pid, 0, buf) < 0
 900           && errno == EIO)
 901         result = tdesc_arm;
 902
 903       free (buf);
 904
 905       return result;
 906     }
 907
 908   /* The default configuration uses legacy FPA registers, probably
 909      simulated.  */
 910   return tdesc_arm;
 911 }
 912
 913 static void
 914 arm_arch_setup (void)
 915 {
 916   int tid = lwpid_of (current_thread);
 917   int gpregs[18];
 918   struct iovec iov;
 919
 920   current_process ()->tdesc = arm_read_description ();
 921
 922   iov.iov_base = gpregs;
 923   iov.iov_len = sizeof (gpregs);
 924
 925   /* Check if PTRACE_GETREGSET works.  */
 926   if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov) == 0)
 927     have_ptrace_getregset = 1;
 928   else
 929     have_ptrace_getregset = 0;
 930 }
 931
 932 /* Fetch the next possible PCs after the current instruction executes.  */
 933
 934 static VEC (CORE_ADDR) *
 935 arm_gdbserver_get_next_pcs (CORE_ADDR pc, struct regcache *regcache)
 936 {
 937   struct arm_get_next_pcs next_pcs_ctx;
 938   VEC (CORE_ADDR) *next_pcs = NULL;
 939
 940   arm_get_next_pcs_ctor (&next_pcs_ctx,
 941                          &get_next_pcs_ops,
 942                          /* Byte order is ignored assumed as host.  */
 943                          0,
 944                          0,
 945                          (const gdb_byte *) &thumb2_breakpoint,
 946                          regcache);
 947
 948   next_pcs = arm_get_next_pcs (&next_pcs_ctx, pc);
 949
 950   return next_pcs;
 951 }
 952
 953 /* Support for hardware single step.  */
 954
 955 static int
 956 arm_supports_hardware_single_step (void)
 957 {
 958   return 0;
 959 }
 960
 961 /* Register sets without using PTRACE_GETREGSET.  */
 962
 963 static struct regset_info arm_regsets[] = {
 964   { PTRACE_GETREGS, PTRACE_SETREGS, 0, 18 * 4,
 965     GENERAL_REGS,
 966     arm_fill_gregset, arm_store_gregset },
 967   { PTRACE_GETWMMXREGS, PTRACE_SETWMMXREGS, 0, 16 * 8 + 6 * 4,
 968     EXTENDED_REGS,
 969     arm_fill_wmmxregset, arm_store_wmmxregset },
 970   { PTRACE_GETVFPREGS, PTRACE_SETVFPREGS, 0, 32 * 8 + 4,
 971     EXTENDED_REGS,
 972     arm_fill_vfpregset, arm_store_vfpregset },
 973   NULL_REGSET
 974 };
 975
 976 static struct regsets_info arm_regsets_info =
 977   {
 978     arm_regsets, /* regsets */
 979     0, /* num_regsets */
 980     NULL, /* disabled_regsets */
 981   };
 982
 983 static struct usrregs_info arm_usrregs_info =
 984   {
 985     arm_num_regs,
 986     arm_regmap,
 987   };
 988
 989 static struct regs_info regs_info_arm =
 990   {
 991     NULL, /* regset_bitmap */
 992     &arm_usrregs_info,
 993     &arm_regsets_info
 994   };
 995
 996 static const struct regs_info *
 997 arm_regs_info (void)
 998 {
 999   const struct target_desc *tdesc = current_process ()->tdesc;
1000
1001   if (have_ptrace_getregset == 1
1002       && (tdesc == tdesc_arm_with_neon || tdesc == tdesc_arm_with_vfpv3))
1003     return &regs_info_aarch32;
1004   else
1005     return &regs_info_arm;
1006 }
1007
1008 struct linux_target_ops the_low_target = {
1009   arm_arch_setup,
1010   arm_regs_info,
1011   arm_cannot_fetch_register,
1012   arm_cannot_store_register,
1013   NULL, /* fetch_register */
1014   arm_get_pc,
1015   arm_set_pc,
1016   arm_breakpoint_kind_from_pc,
1017   arm_sw_breakpoint_from_kind,
1018   arm_gdbserver_get_next_pcs,
1019   0,
1020   arm_breakpoint_at,
1021   arm_supports_z_point_type,
1022   arm_insert_point,
1023   arm_remove_point,
1024   arm_stopped_by_watchpoint,
1025   arm_stopped_data_address,
1026   NULL, /* collect_ptrace_register */
1027   NULL, /* supply_ptrace_register */
1028   NULL, /* siginfo_fixup */
1029   arm_new_process,
1030   arm_new_thread,
1031   arm_new_fork,
1032   arm_prepare_to_resume,
1033   NULL, /* process_qsupported */
1034   NULL, /* supports_tracepoints */
1035   NULL, /* get_thread_area */
1036   NULL, /* install_fast_tracepoint_jump_pad */
1037   NULL, /* emit_ops */
1038   NULL, /* get_min_fast_tracepoint_insn_len */
1039   NULL, /* supports_range_stepping */
1040   arm_breakpoint_kind_from_current_state,
1041   arm_supports_hardware_single_step
1042 };
1043
1044 void
1045 initialize_low_arch (void)
1046 {
1047   /* Initialize the Linux target descriptions.  */
1048   init_registers_arm ();
1049   init_registers_arm_with_iwmmxt ();
1050   init_registers_arm_with_vfpv2 ();
1051   init_registers_arm_with_vfpv3 ();
1052
1053   initialize_low_arch_aarch32 ();
1054
1055   initialize_regsets_info (&arm_regsets_info);
1056 }