1 /* GNU/Linux/ARM specific low level interface, for the remote server for GDB.
2 Copyright (C) 1995-2015 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 "linux-aarch32-low.h"
25 /* Don't include elf.h if linux/elf.h got included by gdb_proc_service.h.
26 On Bionic elf.h and linux/elf.h have conflicting definitions. */
30 #include "nat/gdb_ptrace.h"
33 /* Defined in auto-generated files. */
34 void init_registers_arm (void);
35 extern const struct target_desc
*tdesc_arm
;
37 void init_registers_arm_with_iwmmxt (void);
38 extern const struct target_desc
*tdesc_arm_with_iwmmxt
;
40 void init_registers_arm_with_vfpv2 (void);
41 extern const struct target_desc
*tdesc_arm_with_vfpv2
;
43 void init_registers_arm_with_vfpv3 (void);
44 extern const struct target_desc
*tdesc_arm_with_vfpv3
;
46 #ifndef PTRACE_GET_THREAD_AREA
47 #define PTRACE_GET_THREAD_AREA 22
50 #ifndef PTRACE_GETWMMXREGS
51 # define PTRACE_GETWMMXREGS 18
52 # define PTRACE_SETWMMXREGS 19
55 #ifndef PTRACE_GETVFPREGS
56 # define PTRACE_GETVFPREGS 27
57 # define PTRACE_SETVFPREGS 28
60 #ifndef PTRACE_GETHBPREGS
61 #define PTRACE_GETHBPREGS 29
62 #define PTRACE_SETHBPREGS 30
65 /* Information describing the hardware breakpoint capabilities. */
69 unsigned char max_wp_length
;
70 unsigned char wp_count
;
71 unsigned char bp_count
;
74 /* Enum describing the different types of ARM hardware break-/watch-points. */
83 /* Type describing an ARM Hardware Breakpoint Control register value. */
84 typedef unsigned int arm_hwbp_control_t
;
86 /* Structure used to keep track of hardware break-/watch-points. */
87 struct arm_linux_hw_breakpoint
89 /* Address to break on, or being watched. */
91 /* Control register for break-/watch- point. */
92 arm_hwbp_control_t control
;
95 /* Since we cannot dynamically allocate subfields of arch_process_info,
96 assume a maximum number of supported break-/watchpoints. */
100 /* Per-process arch-specific data we want to keep. */
101 struct arch_process_info
103 /* Hardware breakpoints for this process. */
104 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
105 /* Hardware watchpoints for this process. */
106 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
109 /* Per-thread arch-specific data we want to keep. */
112 /* Non-zero if our copy differs from what's recorded in the thread. */
113 char bpts_changed
[MAX_BPTS
];
114 char wpts_changed
[MAX_WPTS
];
115 /* Cached stopped data address. */
116 CORE_ADDR stopped_data_address
;
119 /* These are in <asm/elf.h> in current kernels. */
121 #define HWCAP_IWMMXT 512
122 #define HWCAP_NEON 4096
123 #define HWCAP_VFPv3 8192
124 #define HWCAP_VFPv3D16 16384
126 #ifdef HAVE_SYS_REG_H
130 #define arm_num_regs 26
132 static int arm_regmap
[] = {
133 0, 4, 8, 12, 16, 20, 24, 28,
134 32, 36, 40, 44, 48, 52, 56, 60,
135 -1, -1, -1, -1, -1, -1, -1, -1, -1,
140 arm_cannot_store_register (int regno
)
142 return (regno
>= arm_num_regs
);
146 arm_cannot_fetch_register (int regno
)
148 return (regno
>= arm_num_regs
);
152 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
156 if (regcache
->tdesc
!= tdesc_arm_with_iwmmxt
)
159 for (i
= 0; i
< 16; i
++)
160 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
162 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
163 for (i
= 0; i
< 6; i
++)
164 collect_register (regcache
, arm_num_regs
+ i
+ 16,
165 (char *) buf
+ 16 * 8 + i
* 4);
169 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
173 if (regcache
->tdesc
!= tdesc_arm_with_iwmmxt
)
176 for (i
= 0; i
< 16; i
++)
177 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
179 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
180 for (i
= 0; i
< 6; i
++)
181 supply_register (regcache
, arm_num_regs
+ i
+ 16,
182 (char *) buf
+ 16 * 8 + i
* 4);
186 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
190 if (regcache
->tdesc
== tdesc_arm_with_neon
191 || regcache
->tdesc
== tdesc_arm_with_vfpv3
)
193 else if (regcache
->tdesc
== tdesc_arm_with_vfpv2
)
198 arm_fill_vfpregset_num (regcache
, buf
, num
);
202 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
206 if (regcache
->tdesc
== tdesc_arm_with_neon
207 || regcache
->tdesc
== tdesc_arm_with_vfpv3
)
209 else if (regcache
->tdesc
== tdesc_arm_with_vfpv2
)
214 arm_store_vfpregset_num (regcache
, buf
, num
);
217 extern int debug_threads
;
220 arm_get_pc (struct regcache
*regcache
)
223 collect_register_by_name (regcache
, "pc", &pc
);
225 debug_printf ("stop pc is %08lx\n", pc
);
230 arm_set_pc (struct regcache
*regcache
, CORE_ADDR pc
)
232 unsigned long newpc
= pc
;
233 supply_register_by_name (regcache
, "pc", &newpc
);
236 /* Correct in either endianness. */
237 static const unsigned long arm_breakpoint
= 0xef9f0001;
238 #define arm_breakpoint_len 4
239 static const unsigned short thumb_breakpoint
= 0xde01;
240 static const unsigned short thumb2_breakpoint
[] = { 0xf7f0, 0xa000 };
242 /* For new EABI binaries. We recognize it regardless of which ABI
243 is used for gdbserver, so single threaded debugging should work
244 OK, but for multi-threaded debugging we only insert the current
245 ABI's breakpoint instruction. For now at least. */
246 static const unsigned long arm_eabi_breakpoint
= 0xe7f001f0;
249 arm_breakpoint_at (CORE_ADDR where
)
251 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
254 collect_register_by_name (regcache
, "cpsr", &cpsr
);
261 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 2);
262 if (insn
== thumb_breakpoint
)
265 if (insn
== thumb2_breakpoint
[0])
267 (*the_target
->read_memory
) (where
+ 2, (unsigned char *) &insn
, 2);
268 if (insn
== thumb2_breakpoint
[1])
277 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 4);
278 if (insn
== arm_breakpoint
)
281 if (insn
== arm_eabi_breakpoint
)
288 /* We only place breakpoints in empty marker functions, and thread locking
289 is outside of the function. So rather than importing software single-step,
290 we can just run until exit. */
292 arm_reinsert_addr (void)
294 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
296 collect_register_by_name (regcache
, "lr", &pc
);
300 /* Fetch the thread-local storage pointer for libthread_db. */
303 ps_get_thread_area (const struct ps_prochandle
*ph
,
304 lwpid_t lwpid
, int idx
, void **base
)
306 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
309 /* IDX is the bias from the thread pointer to the beginning of the
310 thread descriptor. It has to be subtracted due to implementation
311 quirks in libthread_db. */
312 *base
= (void *) ((char *)*base
- idx
);
318 /* Query Hardware Breakpoint information for the target we are attached to
319 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
321 arm_linux_init_hwbp_cap (int pid
)
325 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
328 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
329 if (arm_linux_hwbp_cap
.arch
== 0)
332 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
333 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
334 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
336 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
337 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
338 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
339 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
342 /* How many hardware breakpoints are available? */
344 arm_linux_get_hw_breakpoint_count (void)
346 return arm_linux_hwbp_cap
.bp_count
;
349 /* How many hardware watchpoints are available? */
351 arm_linux_get_hw_watchpoint_count (void)
353 return arm_linux_hwbp_cap
.wp_count
;
356 /* Maximum length of area watched by hardware watchpoint. */
358 arm_linux_get_hw_watchpoint_max_length (void)
360 return arm_linux_hwbp_cap
.max_wp_length
;
363 /* Initialize an ARM hardware break-/watch-point control register value.
364 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
365 type of break-/watch-point; ENABLE indicates whether the point is enabled.
367 static arm_hwbp_control_t
368 arm_hwbp_control_initialize (unsigned byte_address_select
,
369 arm_hwbp_type hwbp_type
,
372 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
373 gdb_assert (hwbp_type
!= arm_hwbp_break
374 || ((byte_address_select
& 0xfU
) != 0));
376 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
379 /* Does the breakpoint control value CONTROL have the enable bit set? */
381 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
383 return control
& 0x1;
386 /* Is the breakpoint control value CONTROL initialized? */
388 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
393 /* Change a breakpoint control word so that it is in the disabled state. */
394 static arm_hwbp_control_t
395 arm_hwbp_control_disable (arm_hwbp_control_t control
)
397 return control
& ~0x1;
400 /* Are two break-/watch-points equal? */
402 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
403 const struct arm_linux_hw_breakpoint
*p2
)
405 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
408 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
411 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
415 case raw_bkpt_type_hw
:
416 return arm_hwbp_break
;
417 case raw_bkpt_type_write_wp
:
418 return arm_hwbp_store
;
419 case raw_bkpt_type_read_wp
:
420 return arm_hwbp_load
;
421 case raw_bkpt_type_access_wp
:
422 return arm_hwbp_access
;
424 gdb_assert_not_reached ("unhandled raw type");
428 /* Initialize the hardware breakpoint structure P for a breakpoint or
429 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
430 Returns -1 if TYPE is unsupported, or -2 if the particular combination
431 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
432 represents a breakpoint and 1 if type represents a watchpoint. */
434 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
435 int len
, struct arm_linux_hw_breakpoint
*p
)
437 arm_hwbp_type hwbp_type
;
440 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
442 if (hwbp_type
== arm_hwbp_break
)
444 /* For breakpoints, the length field encodes the mode. */
447 case 2: /* 16-bit Thumb mode breakpoint */
448 case 3: /* 32-bit Thumb mode breakpoint */
452 case 4: /* 32-bit ARM mode breakpoint */
463 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
464 CORE_ADDR aligned_addr
;
466 /* Can not set watchpoints for zero or negative lengths. */
469 /* The current ptrace interface can only handle watchpoints that are a
471 if ((len
& (len
- 1)) != 0)
474 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
475 range covered by a watchpoint. */
476 aligned_addr
= addr
& ~(max_wp_length
- 1);
477 if (aligned_addr
+ max_wp_length
< addr
+ len
)
480 mask
= (1 << len
) - 1;
483 p
->address
= (unsigned int) addr
;
484 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
486 return hwbp_type
!= arm_hwbp_break
;
489 /* Callback to mark a watch-/breakpoint to be updated in all threads of
490 the current process. */
492 struct update_registers_data
499 update_registers_callback (struct inferior_list_entry
*entry
, void *arg
)
501 struct thread_info
*thread
= (struct thread_info
*) entry
;
502 struct lwp_info
*lwp
= get_thread_lwp (thread
);
503 struct update_registers_data
*data
= (struct update_registers_data
*) arg
;
505 /* Only update the threads of the current process. */
506 if (pid_of (thread
) == pid_of (current_thread
))
508 /* The actual update is done later just before resuming the lwp,
509 we just mark that the registers need updating. */
511 lwp
->arch_private
->wpts_changed
[data
->i
] = 1;
513 lwp
->arch_private
->bpts_changed
[data
->i
] = 1;
515 /* If the lwp isn't stopped, force it to momentarily pause, so
516 we can update its breakpoint registers. */
518 linux_stop_lwp (lwp
);
525 arm_supports_z_point_type (char z_type
)
530 case Z_PACKET_WRITE_WP
:
531 case Z_PACKET_READ_WP
:
532 case Z_PACKET_ACCESS_WP
:
535 /* Leave the handling of sw breakpoints with the gdb client. */
540 /* Insert hardware break-/watchpoint. */
542 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
543 int len
, struct raw_breakpoint
*bp
)
545 struct process_info
*proc
= current_process ();
546 struct arm_linux_hw_breakpoint p
, *pts
;
549 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
553 return watch
== -1 ? 1 : -1;
558 count
= arm_linux_get_hw_watchpoint_count ();
559 pts
= proc
->priv
->arch_private
->wpts
;
563 count
= arm_linux_get_hw_breakpoint_count ();
564 pts
= proc
->priv
->arch_private
->bpts
;
567 for (i
= 0; i
< count
; i
++)
568 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
570 struct update_registers_data data
= { watch
, i
};
572 find_inferior (&all_threads
, update_registers_callback
, &data
);
576 /* We're out of watchpoints. */
580 /* Remove hardware break-/watchpoint. */
582 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
583 int len
, struct raw_breakpoint
*bp
)
585 struct process_info
*proc
= current_process ();
586 struct arm_linux_hw_breakpoint p
, *pts
;
589 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
598 count
= arm_linux_get_hw_watchpoint_count ();
599 pts
= proc
->priv
->arch_private
->wpts
;
603 count
= arm_linux_get_hw_breakpoint_count ();
604 pts
= proc
->priv
->arch_private
->bpts
;
607 for (i
= 0; i
< count
; i
++)
608 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
610 struct update_registers_data data
= { watch
, i
};
611 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
612 find_inferior (&all_threads
, update_registers_callback
, &data
);
616 /* No watchpoint matched. */
620 /* Return whether current thread is stopped due to a watchpoint. */
622 arm_stopped_by_watchpoint (void)
624 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
627 /* We must be able to set hardware watchpoints. */
628 if (arm_linux_get_hw_watchpoint_count () == 0)
631 /* Retrieve siginfo. */
633 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
637 /* This must be a hardware breakpoint. */
638 if (siginfo
.si_signo
!= SIGTRAP
639 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
642 /* If we are in a positive slot then we're looking at a breakpoint and not
644 if (siginfo
.si_errno
>= 0)
647 /* Cache stopped data address for use by arm_stopped_data_address. */
648 lwp
->arch_private
->stopped_data_address
649 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
654 /* Return data address that triggered watchpoint. Called only if
655 arm_stopped_by_watchpoint returned true. */
657 arm_stopped_data_address (void)
659 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
660 return lwp
->arch_private
->stopped_data_address
;
663 /* Called when a new process is created. */
664 static struct arch_process_info
*
665 arm_new_process (void)
667 struct arch_process_info
*info
= xcalloc (1, sizeof (*info
));
671 /* Called when a new thread is detected. */
673 arm_new_thread (struct lwp_info
*lwp
)
675 struct arch_lwp_info
*info
= xcalloc (1, sizeof (*info
));
678 for (i
= 0; i
< MAX_BPTS
; i
++)
679 info
->bpts_changed
[i
] = 1;
680 for (i
= 0; i
< MAX_WPTS
; i
++)
681 info
->wpts_changed
[i
] = 1;
683 lwp
->arch_private
= info
;
687 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
689 struct arch_process_info
*parent_proc_info
= parent
->priv
->arch_private
;
690 struct arch_process_info
*child_proc_info
= child
->priv
->arch_private
;
691 struct lwp_info
*child_lwp
;
692 struct arch_lwp_info
*child_lwp_info
;
695 /* These are allocated by linux_add_process. */
696 gdb_assert (parent
->priv
!= NULL
697 && parent
->priv
->arch_private
!= NULL
);
698 gdb_assert (child
->priv
!= NULL
699 && child
->priv
->arch_private
!= NULL
);
701 /* Linux kernel before 2.6.33 commit
702 72f674d203cd230426437cdcf7dd6f681dad8b0d
703 will inherit hardware debug registers from parent
704 on fork/vfork/clone. Newer Linux kernels create such tasks with
705 zeroed debug registers.
707 GDB core assumes the child inherits the watchpoints/hw
708 breakpoints of the parent, and will remove them all from the
709 forked off process. Copy the debug registers mirrors into the
710 new process so that all breakpoints and watchpoints can be
711 removed together. The debug registers mirror will become zeroed
712 in the end before detaching the forked off process, thus making
713 this compatible with older Linux kernels too. */
715 *child_proc_info
= *parent_proc_info
;
717 /* Mark all the hardware breakpoints and watchpoints as changed to
718 make sure that the registers will be updated. */
719 child_lwp
= find_lwp_pid (ptid_of (child
));
720 child_lwp_info
= child_lwp
->arch_private
;
721 for (i
= 0; i
< MAX_BPTS
; i
++)
722 child_lwp_info
->bpts_changed
[i
] = 1;
723 for (i
= 0; i
< MAX_WPTS
; i
++)
724 child_lwp_info
->wpts_changed
[i
] = 1;
727 /* Called when resuming a thread.
728 If the debug regs have changed, update the thread's copies. */
730 arm_prepare_to_resume (struct lwp_info
*lwp
)
732 struct thread_info
*thread
= get_lwp_thread (lwp
);
733 int pid
= lwpid_of (thread
);
734 struct process_info
*proc
= find_process_pid (pid_of (thread
));
735 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
736 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
739 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
740 if (lwp_info
->bpts_changed
[i
])
744 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
745 if (ptrace (PTRACE_SETHBPREGS
, pid
,
746 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
747 &proc_info
->bpts
[i
].address
) < 0)
748 perror_with_name ("Unexpected error setting breakpoint address");
750 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
751 if (ptrace (PTRACE_SETHBPREGS
, pid
,
752 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
753 &proc_info
->bpts
[i
].control
) < 0)
754 perror_with_name ("Unexpected error setting breakpoint");
756 lwp_info
->bpts_changed
[i
] = 0;
759 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
760 if (lwp_info
->wpts_changed
[i
])
764 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
765 if (ptrace (PTRACE_SETHBPREGS
, pid
,
766 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
767 &proc_info
->wpts
[i
].address
) < 0)
768 perror_with_name ("Unexpected error setting watchpoint address");
770 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
771 if (ptrace (PTRACE_SETHBPREGS
, pid
,
772 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
773 &proc_info
->wpts
[i
].control
) < 0)
774 perror_with_name ("Unexpected error setting watchpoint");
776 lwp_info
->wpts_changed
[i
] = 0;
782 arm_get_hwcap (unsigned long *valp
)
784 unsigned char *data
= alloca (8);
787 while ((*the_target
->read_auxv
) (offset
, data
, 8) == 8)
789 unsigned int *data_p
= (unsigned int *)data
;
790 if (data_p
[0] == AT_HWCAP
)
803 static const struct target_desc
*
804 arm_read_description (void)
806 int pid
= lwpid_of (current_thread
);
807 unsigned long arm_hwcap
= 0;
809 /* Query hardware watchpoint/breakpoint capabilities. */
810 arm_linux_init_hwbp_cap (pid
);
812 if (arm_get_hwcap (&arm_hwcap
) == 0)
815 if (arm_hwcap
& HWCAP_IWMMXT
)
816 return tdesc_arm_with_iwmmxt
;
818 if (arm_hwcap
& HWCAP_VFP
)
820 const struct target_desc
*result
;
823 /* NEON implies either no VFP, or VFPv3-D32. We only support
825 if (arm_hwcap
& HWCAP_NEON
)
826 result
= tdesc_arm_with_neon
;
827 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
828 result
= tdesc_arm_with_vfpv3
;
830 result
= tdesc_arm_with_vfpv2
;
832 /* Now make sure that the kernel supports reading these
833 registers. Support was added in 2.6.30. */
835 buf
= xmalloc (32 * 8 + 4);
836 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0
845 /* The default configuration uses legacy FPA registers, probably
851 arm_arch_setup (void)
853 int tid
= lwpid_of (current_thread
);
857 current_process ()->tdesc
= arm_read_description ();
859 iov
.iov_base
= gpregs
;
860 iov
.iov_len
= sizeof (gpregs
);
862 /* Check if PTRACE_GETREGSET works. */
863 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
864 have_ptrace_getregset
= 1;
866 have_ptrace_getregset
= 0;
869 /* Register sets without using PTRACE_GETREGSET. */
871 static struct regset_info arm_regsets
[] = {
872 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0, 18 * 4,
874 arm_fill_gregset
, arm_store_gregset
},
875 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, 16 * 8 + 6 * 4,
877 arm_fill_wmmxregset
, arm_store_wmmxregset
},
878 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, 32 * 8 + 4,
880 arm_fill_vfpregset
, arm_store_vfpregset
},
881 { 0, 0, 0, -1, -1, NULL
, NULL
}
884 static struct regsets_info arm_regsets_info
=
886 arm_regsets
, /* regsets */
888 NULL
, /* disabled_regsets */
891 static struct usrregs_info arm_usrregs_info
=
897 static struct regs_info regs_info_arm
=
899 NULL
, /* regset_bitmap */
904 static const struct regs_info
*
907 const struct target_desc
*tdesc
= current_process ()->tdesc
;
909 if (have_ptrace_getregset
== 1
910 && (tdesc
== tdesc_arm_with_neon
|| tdesc
== tdesc_arm_with_vfpv3
))
911 return ®s_info_aarch32
;
913 return ®s_info_arm
;
916 struct linux_target_ops the_low_target
= {
919 arm_cannot_fetch_register
,
920 arm_cannot_store_register
,
921 NULL
, /* fetch_register */
925 /* Define an ARM-mode breakpoint; we only set breakpoints in the C
926 library, which is most likely to be ARM. If the kernel supports
927 clone events, we will never insert a breakpoint, so even a Thumb
928 C library will work; so will mixing EABI/non-EABI gdbserver and
931 (const unsigned char *) &arm_breakpoint
,
933 (const unsigned char *) &arm_eabi_breakpoint
,
939 arm_supports_z_point_type
,
942 arm_stopped_by_watchpoint
,
943 arm_stopped_data_address
,
944 NULL
, /* collect_ptrace_register */
945 NULL
, /* supply_ptrace_register */
946 NULL
, /* siginfo_fixup */
950 arm_prepare_to_resume
,
954 initialize_low_arch (void)
956 /* Initialize the Linux target descriptions. */
957 init_registers_arm ();
958 init_registers_arm_with_iwmmxt ();
959 init_registers_arm_with_vfpv2 ();
960 init_registers_arm_with_vfpv3 ();
962 initialize_low_arch_aarch32 ();
964 initialize_regsets_info (&arm_regsets_info
);