1 /* GNU/Linux/ARM specific low level interface, for the remote server for GDB.
2 Copyright (C) 1995-2016 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
20 #include "linux-low.h"
22 #include "arch/arm-linux.h"
23 #include "arch/arm-get-next-pcs.h"
24 #include "linux-aarch32-low.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. */
32 #include "nat/gdb_ptrace.h"
34 #include <sys/syscall.h>
36 /* Defined in auto-generated files. */
37 void init_registers_arm (void);
38 extern const struct target_desc *tdesc_arm;
40 void init_registers_arm_with_iwmmxt (void);
41 extern const struct target_desc *tdesc_arm_with_iwmmxt;
43 void init_registers_arm_with_vfpv2 (void);
44 extern const struct target_desc *tdesc_arm_with_vfpv2;
46 void init_registers_arm_with_vfpv3 (void);
47 extern const struct target_desc *tdesc_arm_with_vfpv3;
49 #ifndef PTRACE_GET_THREAD_AREA
50 #define PTRACE_GET_THREAD_AREA 22
53 #ifndef PTRACE_GETWMMXREGS
54 # define PTRACE_GETWMMXREGS 18
55 # define PTRACE_SETWMMXREGS 19
58 #ifndef PTRACE_GETVFPREGS
59 # define PTRACE_GETVFPREGS 27
60 # define PTRACE_SETVFPREGS 28
63 #ifndef PTRACE_GETHBPREGS
64 #define PTRACE_GETHBPREGS 29
65 #define PTRACE_SETHBPREGS 30
68 /* Information describing the hardware breakpoint capabilities. */
72 unsigned char max_wp_length;
73 unsigned char wp_count;
74 unsigned char bp_count;
77 /* Enum describing the different types of ARM hardware break-/watch-points. */
86 /* Type describing an ARM Hardware Breakpoint Control register value. */
87 typedef unsigned int arm_hwbp_control_t;
89 /* Structure used to keep track of hardware break-/watch-points. */
90 struct arm_linux_hw_breakpoint
92 /* Address to break on, or being watched. */
94 /* Control register for break-/watch- point. */
95 arm_hwbp_control_t control;
98 /* Since we cannot dynamically allocate subfields of arch_process_info,
99 assume a maximum number of supported break-/watchpoints. */
103 /* Per-process arch-specific data we want to keep. */
104 struct arch_process_info
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];
112 /* Per-thread arch-specific data we want to keep. */
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;
122 /* These are in <asm/elf.h> in current kernels. */
124 #define HWCAP_IWMMXT 512
125 #define HWCAP_NEON 4096
126 #define HWCAP_VFPv3 8192
127 #define HWCAP_VFPv3D16 16384
129 #ifdef HAVE_SYS_REG_H
133 #define arm_num_regs 26
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,
142 /* Forward declarations needed for get_next_pcs ops. */
143 static ULONGEST get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr,
147 static CORE_ADDR get_next_pcs_addr_bits_remove (struct arm_get_next_pcs *self,
150 static CORE_ADDR get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self,
153 static int get_next_pcs_is_thumb (struct arm_get_next_pcs *self);
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
164 arm_cannot_store_register (int regno)
166 return (regno >= arm_num_regs);
170 arm_cannot_fetch_register (int regno)
172 return (regno >= arm_num_regs);
176 arm_fill_wmmxregset (struct regcache *regcache, void *buf)
180 if (regcache->tdesc != tdesc_arm_with_iwmmxt)
183 for (i = 0; i < 16; i++)
184 collect_register (regcache, arm_num_regs + i, (char *) buf + i * 8);
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);
193 arm_store_wmmxregset (struct regcache *regcache, const void *buf)
197 if (regcache->tdesc != tdesc_arm_with_iwmmxt)
200 for (i = 0; i < 16; i++)
201 supply_register (regcache, arm_num_regs + i, (char *) buf + i * 8);
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);
210 arm_fill_vfpregset (struct regcache *regcache, void *buf)
214 if (regcache->tdesc == tdesc_arm_with_neon
215 || regcache->tdesc == tdesc_arm_with_vfpv3)
217 else if (regcache->tdesc == tdesc_arm_with_vfpv2)
222 arm_fill_vfpregset_num (regcache, buf, num);
225 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
227 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs *self, CORE_ADDR val)
229 return UNMAKE_THUMB_ADDR (val);
233 arm_store_vfpregset (struct regcache *regcache, const void *buf)
237 if (regcache->tdesc == tdesc_arm_with_neon
238 || regcache->tdesc == tdesc_arm_with_vfpv3)
240 else if (regcache->tdesc == tdesc_arm_with_vfpv2)
245 arm_store_vfpregset_num (regcache, buf, num);
248 extern int debug_threads;
251 arm_get_pc (struct regcache *regcache)
254 collect_register_by_name (regcache, "pc", &pc);
256 debug_printf ("stop pc is %08lx\n", pc);
261 arm_set_pc (struct regcache *regcache, CORE_ADDR pc)
263 unsigned long newpc = pc;
264 supply_register_by_name (regcache, "pc", &newpc);
267 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
269 get_next_pcs_is_thumb (struct arm_get_next_pcs *self)
271 return arm_is_thumb_mode ();
274 /* Read memory from the inferiror.
275 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
276 read_memory_unsigned_integer. */
278 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr,
284 (*the_target->read_memory) (memaddr, (unsigned char *) &res, len);
288 /* Fetch the thread-local storage pointer for libthread_db. */
291 ps_get_thread_area (const struct ps_prochandle *ph,
292 lwpid_t lwpid, int idx, void **base)
294 if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
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);
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. */
309 arm_linux_init_hwbp_cap (int pid)
313 if (ptrace (PTRACE_GETHBPREGS, pid, 0, &val) < 0)
316 arm_linux_hwbp_cap.arch = (unsigned char)((val >> 24) & 0xff);
317 if (arm_linux_hwbp_cap.arch == 0)
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);
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");
330 /* How many hardware breakpoints are available? */
332 arm_linux_get_hw_breakpoint_count (void)
334 return arm_linux_hwbp_cap.bp_count;
337 /* How many hardware watchpoints are available? */
339 arm_linux_get_hw_watchpoint_count (void)
341 return arm_linux_hwbp_cap.wp_count;
344 /* Maximum length of area watched by hardware watchpoint. */
346 arm_linux_get_hw_watchpoint_max_length (void)
348 return arm_linux_hwbp_cap.max_wp_length;
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.
355 static arm_hwbp_control_t
356 arm_hwbp_control_initialize (unsigned byte_address_select,
357 arm_hwbp_type hwbp_type,
360 gdb_assert ((byte_address_select & ~0xffU) == 0);
361 gdb_assert (hwbp_type != arm_hwbp_break
362 || ((byte_address_select & 0xfU) != 0));
364 return (byte_address_select << 5) | (hwbp_type << 3) | (3 << 1) | enable;
367 /* Does the breakpoint control value CONTROL have the enable bit set? */
369 arm_hwbp_control_is_enabled (arm_hwbp_control_t control)
371 return control & 0x1;
374 /* Is the breakpoint control value CONTROL initialized? */
376 arm_hwbp_control_is_initialized (arm_hwbp_control_t control)
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)
385 return control & ~0x1;
388 /* Are two break-/watch-points equal? */
390 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint *p1,
391 const struct arm_linux_hw_breakpoint *p2)
393 return p1->address == p2->address && p1->control == p2->control;
396 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
399 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type)
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;
412 gdb_assert_not_reached ("unhandled raw type");
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. */
422 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type, CORE_ADDR addr,
423 int len, struct arm_linux_hw_breakpoint *p)
425 arm_hwbp_type hwbp_type;
428 hwbp_type = raw_bkpt_type_to_arm_hwbp_type (raw_type);
430 if (hwbp_type == arm_hwbp_break)
432 /* For breakpoints, the length field encodes the mode. */
435 case 2: /* 16-bit Thumb mode breakpoint */
436 case 3: /* 32-bit Thumb mode breakpoint */
440 case 4: /* 32-bit ARM mode breakpoint */
451 CORE_ADDR max_wp_length = arm_linux_get_hw_watchpoint_max_length ();
452 CORE_ADDR aligned_addr;
454 /* Can not set watchpoints for zero or negative lengths. */
457 /* The current ptrace interface can only handle watchpoints that are a
459 if ((len & (len - 1)) != 0)
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)
468 mask = (1 << len) - 1;
471 p->address = (unsigned int) addr;
472 p->control = arm_hwbp_control_initialize (mask, hwbp_type, 1);
474 return hwbp_type != arm_hwbp_break;
477 /* Callback to mark a watch-/breakpoint to be updated in all threads of
478 the current process. */
480 struct update_registers_data
487 update_registers_callback (struct inferior_list_entry *entry, void *arg)
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;
493 /* Only update the threads of the current process. */
494 if (pid_of (thread) == pid_of (current_thread))
496 /* The actual update is done later just before resuming the lwp,
497 we just mark that the registers need updating. */
499 lwp->arch_private->wpts_changed[data->i] = 1;
501 lwp->arch_private->bpts_changed[data->i] = 1;
503 /* If the lwp isn't stopped, force it to momentarily pause, so
504 we can update its breakpoint registers. */
506 linux_stop_lwp (lwp);
513 arm_supports_z_point_type (char z_type)
519 case Z_PACKET_WRITE_WP:
520 case Z_PACKET_READ_WP:
521 case Z_PACKET_ACCESS_WP:
524 /* Leave the handling of sw breakpoints with the gdb client. */
529 /* Insert hardware break-/watchpoint. */
531 arm_insert_point (enum raw_bkpt_type type, CORE_ADDR addr,
532 int len, struct raw_breakpoint *bp)
534 struct process_info *proc = current_process ();
535 struct arm_linux_hw_breakpoint p, *pts;
538 watch = arm_linux_hw_point_initialize (type, addr, len, &p);
542 return watch == -1 ? 1 : -1;
547 count = arm_linux_get_hw_watchpoint_count ();
548 pts = proc->priv->arch_private->wpts;
552 count = arm_linux_get_hw_breakpoint_count ();
553 pts = proc->priv->arch_private->bpts;
556 for (i = 0; i < count; i++)
557 if (!arm_hwbp_control_is_enabled (pts[i].control))
559 struct update_registers_data data = { watch, i };
561 find_inferior (&all_threads, update_registers_callback, &data);
565 /* We're out of watchpoints. */
569 /* Remove hardware break-/watchpoint. */
571 arm_remove_point (enum raw_bkpt_type type, CORE_ADDR addr,
572 int len, struct raw_breakpoint *bp)
574 struct process_info *proc = current_process ();
575 struct arm_linux_hw_breakpoint p, *pts;
578 watch = arm_linux_hw_point_initialize (type, addr, len, &p);
587 count = arm_linux_get_hw_watchpoint_count ();
588 pts = proc->priv->arch_private->wpts;
592 count = arm_linux_get_hw_breakpoint_count ();
593 pts = proc->priv->arch_private->bpts;
596 for (i = 0; i < count; i++)
597 if (arm_linux_hw_breakpoint_equal (&p, pts + i))
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);
605 /* No watchpoint matched. */
609 /* Return whether current thread is stopped due to a watchpoint. */
611 arm_stopped_by_watchpoint (void)
613 struct lwp_info *lwp = get_thread_lwp (current_thread);
616 /* We must be able to set hardware watchpoints. */
617 if (arm_linux_get_hw_watchpoint_count () == 0)
620 /* Retrieve siginfo. */
622 ptrace (PTRACE_GETSIGINFO, lwpid_of (current_thread), 0, &siginfo);
626 /* This must be a hardware breakpoint. */
627 if (siginfo.si_signo != SIGTRAP
628 || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */)
631 /* If we are in a positive slot then we're looking at a breakpoint and not
633 if (siginfo.si_errno >= 0)
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;
643 /* Return data address that triggered watchpoint. Called only if
644 arm_stopped_by_watchpoint returned true. */
646 arm_stopped_data_address (void)
648 struct lwp_info *lwp = get_thread_lwp (current_thread);
649 return lwp->arch_private->stopped_data_address;
652 /* Called when a new process is created. */
653 static struct arch_process_info *
654 arm_new_process (void)
656 struct arch_process_info *info = XCNEW (struct arch_process_info);
660 /* Called when a new thread is detected. */
662 arm_new_thread (struct lwp_info *lwp)
664 struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
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;
672 lwp->arch_private = info;
676 arm_new_fork (struct process_info *parent, struct process_info *child)
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;
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);
690 parent_proc_info = parent->priv->arch_private;
691 child_proc_info = child->priv->arch_private;
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.
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. */
707 *child_proc_info = *parent_proc_info;
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;
719 /* Called when resuming a thread.
720 If the debug regs have changed, update the thread's copies. */
722 arm_prepare_to_resume (struct lwp_info *lwp)
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;
731 for (i = 0; i < arm_linux_get_hw_breakpoint_count (); i++)
732 if (lwp_info->bpts_changed[i])
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");
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");
748 lwp_info->bpts_changed[i] = 0;
751 for (i = 0; i < arm_linux_get_hw_watchpoint_count (); i++)
752 if (lwp_info->wpts_changed[i])
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");
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");
768 lwp_info->wpts_changed[i] = 0;
772 /* Find the next pc for a sigreturn or rt_sigreturn syscall.
773 See arm-linux.h for stack layout details. */
775 arm_sigreturn_next_pc (struct regcache *regcache, int svc_number)
778 unsigned long sp_data;
779 /* Offset of PC register. */
781 CORE_ADDR next_pc = 0;
783 gdb_assert (svc_number == __NR_sigreturn || svc_number == __NR_rt_sigreturn);
785 collect_register_by_name (regcache, "sp", &sp);
786 (*the_target->read_memory) (sp, (unsigned char *) &sp_data, 4);
788 pc_offset = arm_linux_sigreturn_next_pc_offset
789 (sp, sp_data, svc_number, __NR_sigreturn == svc_number ? 1 : 0);
791 (*the_target->read_memory) (sp + pc_offset, (unsigned char *) &next_pc, 4);
796 /* When PC is at a syscall instruction, return the PC of the next
797 instruction to be executed. */
799 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self, CORE_ADDR pc)
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;
808 collect_register (regcache, 7, &svc_number);
813 unsigned long this_instr;
814 unsigned long svc_operand;
816 (*the_target->read_memory) (pc, (unsigned char *) &this_instr, 4);
817 svc_operand = (0x00ffffff & this_instr);
819 if (svc_operand) /* OABI. */
821 svc_number = svc_operand - 0x900000;
825 collect_register (regcache, 7, &svc_number);
831 /* This is a sigreturn or sigreturn_rt syscall. */
832 if (svc_number == __NR_sigreturn || svc_number == __NR_rt_sigreturn)
834 next_pc = arm_sigreturn_next_pc (regcache, svc_number);
837 /* Addresses for calling Thumb functions have the bit 0 set. */
839 next_pc = MAKE_THUMB_ADDR (next_pc);
845 arm_get_hwcap (unsigned long *valp)
847 unsigned char *data = (unsigned char *) alloca (8);
850 while ((*the_target->read_auxv) (offset, data, 8) == 8)
852 unsigned int *data_p = (unsigned int *)data;
853 if (data_p[0] == AT_HWCAP)
866 static const struct target_desc *
867 arm_read_description (void)
869 int pid = lwpid_of (current_thread);
870 unsigned long arm_hwcap = 0;
872 /* Query hardware watchpoint/breakpoint capabilities. */
873 arm_linux_init_hwbp_cap (pid);
875 if (arm_get_hwcap (&arm_hwcap) == 0)
878 if (arm_hwcap & HWCAP_IWMMXT)
879 return tdesc_arm_with_iwmmxt;
881 if (arm_hwcap & HWCAP_VFP)
883 const struct target_desc *result;
886 /* NEON implies either no VFP, or VFPv3-D32. We only support
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;
893 result = tdesc_arm_with_vfpv2;
895 /* Now make sure that the kernel supports reading these
896 registers. Support was added in 2.6.30. */
898 buf = (char *) xmalloc (32 * 8 + 4);
899 if (ptrace (PTRACE_GETVFPREGS, pid, 0, buf) < 0
908 /* The default configuration uses legacy FPA registers, probably
914 arm_arch_setup (void)
916 int tid = lwpid_of (current_thread);
920 current_process ()->tdesc = arm_read_description ();
922 iov.iov_base = gpregs;
923 iov.iov_len = sizeof (gpregs);
925 /* Check if PTRACE_GETREGSET works. */
926 if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS, &iov) == 0)
927 have_ptrace_getregset = 1;
929 have_ptrace_getregset = 0;
932 /* Fetch the next possible PCs after the current instruction executes. */
934 static VEC (CORE_ADDR) *
935 arm_gdbserver_get_next_pcs (CORE_ADDR pc, struct regcache *regcache)
937 struct arm_get_next_pcs next_pcs_ctx;
938 VEC (CORE_ADDR) *next_pcs = NULL;
940 arm_get_next_pcs_ctor (&next_pcs_ctx,
942 /* Byte order is ignored assumed as host. */
948 next_pcs = arm_get_next_pcs (&next_pcs_ctx, pc);
953 /* Support for hardware single step. */
956 arm_supports_hardware_single_step (void)
961 /* Register sets without using PTRACE_GETREGSET. */
963 static struct regset_info arm_regsets[] = {
964 { PTRACE_GETREGS, PTRACE_SETREGS, 0, 18 * 4,
966 arm_fill_gregset, arm_store_gregset },
967 { PTRACE_GETWMMXREGS, PTRACE_SETWMMXREGS, 0, 16 * 8 + 6 * 4,
969 arm_fill_wmmxregset, arm_store_wmmxregset },
970 { PTRACE_GETVFPREGS, PTRACE_SETVFPREGS, 0, 32 * 8 + 4,
972 arm_fill_vfpregset, arm_store_vfpregset },
976 static struct regsets_info arm_regsets_info =
978 arm_regsets, /* regsets */
980 NULL, /* disabled_regsets */
983 static struct usrregs_info arm_usrregs_info =
989 static struct regs_info regs_info_arm =
991 NULL, /* regset_bitmap */
996 static const struct regs_info *
999 const struct target_desc *tdesc = current_process ()->tdesc;
1001 if (have_ptrace_getregset == 1
1002 && (tdesc == tdesc_arm_with_neon || tdesc == tdesc_arm_with_vfpv3))
1003 return ®s_info_aarch32;
1005 return ®s_info_arm;
1008 struct linux_target_ops the_low_target = {
1011 arm_cannot_fetch_register,
1012 arm_cannot_store_register,
1013 NULL, /* fetch_register */
1016 arm_breakpoint_kind_from_pc,
1017 arm_sw_breakpoint_from_kind,
1018 arm_gdbserver_get_next_pcs,
1021 arm_supports_z_point_type,
1024 arm_stopped_by_watchpoint,
1025 arm_stopped_data_address,
1026 NULL, /* collect_ptrace_register */
1027 NULL, /* supply_ptrace_register */
1028 NULL, /* siginfo_fixup */
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
1045 initialize_low_arch (void)
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 ();
1053 initialize_low_arch_aarch32 ();
1055 initialize_regsets_info (&arm_regsets_info);