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 /* Fetch the thread-local storage pointer for libthread_db. */
239 ps_get_thread_area (const struct ps_prochandle
*ph
,
240 lwpid_t lwpid
, int idx
, void **base
)
242 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
245 /* IDX is the bias from the thread pointer to the beginning of the
246 thread descriptor. It has to be subtracted due to implementation
247 quirks in libthread_db. */
248 *base
= (void *) ((char *)*base
- idx
);
254 /* Query Hardware Breakpoint information for the target we are attached to
255 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
257 arm_linux_init_hwbp_cap (int pid
)
261 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
264 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
265 if (arm_linux_hwbp_cap
.arch
== 0)
268 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
269 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
270 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
272 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
273 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
274 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
275 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
278 /* How many hardware breakpoints are available? */
280 arm_linux_get_hw_breakpoint_count (void)
282 return arm_linux_hwbp_cap
.bp_count
;
285 /* How many hardware watchpoints are available? */
287 arm_linux_get_hw_watchpoint_count (void)
289 return arm_linux_hwbp_cap
.wp_count
;
292 /* Maximum length of area watched by hardware watchpoint. */
294 arm_linux_get_hw_watchpoint_max_length (void)
296 return arm_linux_hwbp_cap
.max_wp_length
;
299 /* Initialize an ARM hardware break-/watch-point control register value.
300 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
301 type of break-/watch-point; ENABLE indicates whether the point is enabled.
303 static arm_hwbp_control_t
304 arm_hwbp_control_initialize (unsigned byte_address_select
,
305 arm_hwbp_type hwbp_type
,
308 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
309 gdb_assert (hwbp_type
!= arm_hwbp_break
310 || ((byte_address_select
& 0xfU
) != 0));
312 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
315 /* Does the breakpoint control value CONTROL have the enable bit set? */
317 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
319 return control
& 0x1;
322 /* Is the breakpoint control value CONTROL initialized? */
324 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
329 /* Change a breakpoint control word so that it is in the disabled state. */
330 static arm_hwbp_control_t
331 arm_hwbp_control_disable (arm_hwbp_control_t control
)
333 return control
& ~0x1;
336 /* Are two break-/watch-points equal? */
338 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
339 const struct arm_linux_hw_breakpoint
*p2
)
341 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
344 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
347 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
351 case raw_bkpt_type_hw
:
352 return arm_hwbp_break
;
353 case raw_bkpt_type_write_wp
:
354 return arm_hwbp_store
;
355 case raw_bkpt_type_read_wp
:
356 return arm_hwbp_load
;
357 case raw_bkpt_type_access_wp
:
358 return arm_hwbp_access
;
360 gdb_assert_not_reached ("unhandled raw type");
364 /* Initialize the hardware breakpoint structure P for a breakpoint or
365 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
366 Returns -1 if TYPE is unsupported, or -2 if the particular combination
367 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
368 represents a breakpoint and 1 if type represents a watchpoint. */
370 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
371 int len
, struct arm_linux_hw_breakpoint
*p
)
373 arm_hwbp_type hwbp_type
;
376 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
378 if (hwbp_type
== arm_hwbp_break
)
380 /* For breakpoints, the length field encodes the mode. */
383 case 2: /* 16-bit Thumb mode breakpoint */
384 case 3: /* 32-bit Thumb mode breakpoint */
388 case 4: /* 32-bit ARM mode breakpoint */
399 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
400 CORE_ADDR aligned_addr
;
402 /* Can not set watchpoints for zero or negative lengths. */
405 /* The current ptrace interface can only handle watchpoints that are a
407 if ((len
& (len
- 1)) != 0)
410 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
411 range covered by a watchpoint. */
412 aligned_addr
= addr
& ~(max_wp_length
- 1);
413 if (aligned_addr
+ max_wp_length
< addr
+ len
)
416 mask
= (1 << len
) - 1;
419 p
->address
= (unsigned int) addr
;
420 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
422 return hwbp_type
!= arm_hwbp_break
;
425 /* Callback to mark a watch-/breakpoint to be updated in all threads of
426 the current process. */
428 struct update_registers_data
435 update_registers_callback (struct inferior_list_entry
*entry
, void *arg
)
437 struct thread_info
*thread
= (struct thread_info
*) entry
;
438 struct lwp_info
*lwp
= get_thread_lwp (thread
);
439 struct update_registers_data
*data
= (struct update_registers_data
*) arg
;
441 /* Only update the threads of the current process. */
442 if (pid_of (thread
) == pid_of (current_thread
))
444 /* The actual update is done later just before resuming the lwp,
445 we just mark that the registers need updating. */
447 lwp
->arch_private
->wpts_changed
[data
->i
] = 1;
449 lwp
->arch_private
->bpts_changed
[data
->i
] = 1;
451 /* If the lwp isn't stopped, force it to momentarily pause, so
452 we can update its breakpoint registers. */
454 linux_stop_lwp (lwp
);
461 arm_supports_z_point_type (char z_type
)
467 case Z_PACKET_WRITE_WP
:
468 case Z_PACKET_READ_WP
:
469 case Z_PACKET_ACCESS_WP
:
472 /* Leave the handling of sw breakpoints with the gdb client. */
477 /* Insert hardware break-/watchpoint. */
479 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
480 int len
, struct raw_breakpoint
*bp
)
482 struct process_info
*proc
= current_process ();
483 struct arm_linux_hw_breakpoint p
, *pts
;
486 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
490 return watch
== -1 ? 1 : -1;
495 count
= arm_linux_get_hw_watchpoint_count ();
496 pts
= proc
->priv
->arch_private
->wpts
;
500 count
= arm_linux_get_hw_breakpoint_count ();
501 pts
= proc
->priv
->arch_private
->bpts
;
504 for (i
= 0; i
< count
; i
++)
505 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
507 struct update_registers_data data
= { watch
, i
};
509 find_inferior (&all_threads
, update_registers_callback
, &data
);
513 /* We're out of watchpoints. */
517 /* Remove hardware break-/watchpoint. */
519 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
520 int len
, struct raw_breakpoint
*bp
)
522 struct process_info
*proc
= current_process ();
523 struct arm_linux_hw_breakpoint p
, *pts
;
526 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
535 count
= arm_linux_get_hw_watchpoint_count ();
536 pts
= proc
->priv
->arch_private
->wpts
;
540 count
= arm_linux_get_hw_breakpoint_count ();
541 pts
= proc
->priv
->arch_private
->bpts
;
544 for (i
= 0; i
< count
; i
++)
545 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
547 struct update_registers_data data
= { watch
, i
};
548 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
549 find_inferior (&all_threads
, update_registers_callback
, &data
);
553 /* No watchpoint matched. */
557 /* Return whether current thread is stopped due to a watchpoint. */
559 arm_stopped_by_watchpoint (void)
561 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
564 /* We must be able to set hardware watchpoints. */
565 if (arm_linux_get_hw_watchpoint_count () == 0)
568 /* Retrieve siginfo. */
570 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
574 /* This must be a hardware breakpoint. */
575 if (siginfo
.si_signo
!= SIGTRAP
576 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
579 /* If we are in a positive slot then we're looking at a breakpoint and not
581 if (siginfo
.si_errno
>= 0)
584 /* Cache stopped data address for use by arm_stopped_data_address. */
585 lwp
->arch_private
->stopped_data_address
586 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
591 /* Return data address that triggered watchpoint. Called only if
592 arm_stopped_by_watchpoint returned true. */
594 arm_stopped_data_address (void)
596 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
597 return lwp
->arch_private
->stopped_data_address
;
600 /* Called when a new process is created. */
601 static struct arch_process_info
*
602 arm_new_process (void)
604 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
608 /* Called when a new thread is detected. */
610 arm_new_thread (struct lwp_info
*lwp
)
612 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
615 for (i
= 0; i
< MAX_BPTS
; i
++)
616 info
->bpts_changed
[i
] = 1;
617 for (i
= 0; i
< MAX_WPTS
; i
++)
618 info
->wpts_changed
[i
] = 1;
620 lwp
->arch_private
= info
;
624 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
626 struct arch_process_info
*parent_proc_info
;
627 struct arch_process_info
*child_proc_info
;
628 struct lwp_info
*child_lwp
;
629 struct arch_lwp_info
*child_lwp_info
;
632 /* These are allocated by linux_add_process. */
633 gdb_assert (parent
->priv
!= NULL
634 && parent
->priv
->arch_private
!= NULL
);
635 gdb_assert (child
->priv
!= NULL
636 && child
->priv
->arch_private
!= NULL
);
638 parent_proc_info
= parent
->priv
->arch_private
;
639 child_proc_info
= child
->priv
->arch_private
;
641 /* Linux kernel before 2.6.33 commit
642 72f674d203cd230426437cdcf7dd6f681dad8b0d
643 will inherit hardware debug registers from parent
644 on fork/vfork/clone. Newer Linux kernels create such tasks with
645 zeroed debug registers.
647 GDB core assumes the child inherits the watchpoints/hw
648 breakpoints of the parent, and will remove them all from the
649 forked off process. Copy the debug registers mirrors into the
650 new process so that all breakpoints and watchpoints can be
651 removed together. The debug registers mirror will become zeroed
652 in the end before detaching the forked off process, thus making
653 this compatible with older Linux kernels too. */
655 *child_proc_info
= *parent_proc_info
;
657 /* Mark all the hardware breakpoints and watchpoints as changed to
658 make sure that the registers will be updated. */
659 child_lwp
= find_lwp_pid (ptid_of (child
));
660 child_lwp_info
= child_lwp
->arch_private
;
661 for (i
= 0; i
< MAX_BPTS
; i
++)
662 child_lwp_info
->bpts_changed
[i
] = 1;
663 for (i
= 0; i
< MAX_WPTS
; i
++)
664 child_lwp_info
->wpts_changed
[i
] = 1;
667 /* Called when resuming a thread.
668 If the debug regs have changed, update the thread's copies. */
670 arm_prepare_to_resume (struct lwp_info
*lwp
)
672 struct thread_info
*thread
= get_lwp_thread (lwp
);
673 int pid
= lwpid_of (thread
);
674 struct process_info
*proc
= find_process_pid (pid_of (thread
));
675 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
676 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
679 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
680 if (lwp_info
->bpts_changed
[i
])
684 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
685 if (ptrace (PTRACE_SETHBPREGS
, pid
,
686 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
687 &proc_info
->bpts
[i
].address
) < 0)
688 perror_with_name ("Unexpected error setting breakpoint address");
690 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
691 if (ptrace (PTRACE_SETHBPREGS
, pid
,
692 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
693 &proc_info
->bpts
[i
].control
) < 0)
694 perror_with_name ("Unexpected error setting breakpoint");
696 lwp_info
->bpts_changed
[i
] = 0;
699 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
700 if (lwp_info
->wpts_changed
[i
])
704 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
705 if (ptrace (PTRACE_SETHBPREGS
, pid
,
706 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
707 &proc_info
->wpts
[i
].address
) < 0)
708 perror_with_name ("Unexpected error setting watchpoint address");
710 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
711 if (ptrace (PTRACE_SETHBPREGS
, pid
,
712 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
713 &proc_info
->wpts
[i
].control
) < 0)
714 perror_with_name ("Unexpected error setting watchpoint");
716 lwp_info
->wpts_changed
[i
] = 0;
722 arm_get_hwcap (unsigned long *valp
)
724 unsigned char *data
= (unsigned char *) alloca (8);
727 while ((*the_target
->read_auxv
) (offset
, data
, 8) == 8)
729 unsigned int *data_p
= (unsigned int *)data
;
730 if (data_p
[0] == AT_HWCAP
)
743 static const struct target_desc
*
744 arm_read_description (void)
746 int pid
= lwpid_of (current_thread
);
747 unsigned long arm_hwcap
= 0;
749 /* Query hardware watchpoint/breakpoint capabilities. */
750 arm_linux_init_hwbp_cap (pid
);
752 if (arm_get_hwcap (&arm_hwcap
) == 0)
755 if (arm_hwcap
& HWCAP_IWMMXT
)
756 return tdesc_arm_with_iwmmxt
;
758 if (arm_hwcap
& HWCAP_VFP
)
760 const struct target_desc
*result
;
763 /* NEON implies either no VFP, or VFPv3-D32. We only support
765 if (arm_hwcap
& HWCAP_NEON
)
766 result
= tdesc_arm_with_neon
;
767 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
768 result
= tdesc_arm_with_vfpv3
;
770 result
= tdesc_arm_with_vfpv2
;
772 /* Now make sure that the kernel supports reading these
773 registers. Support was added in 2.6.30. */
775 buf
= (char *) xmalloc (32 * 8 + 4);
776 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0
785 /* The default configuration uses legacy FPA registers, probably
791 arm_arch_setup (void)
793 int tid
= lwpid_of (current_thread
);
797 current_process ()->tdesc
= arm_read_description ();
799 iov
.iov_base
= gpregs
;
800 iov
.iov_len
= sizeof (gpregs
);
802 /* Check if PTRACE_GETREGSET works. */
803 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
804 have_ptrace_getregset
= 1;
806 have_ptrace_getregset
= 0;
809 /* Support for hardware single step. */
812 arm_supports_hardware_single_step (void)
817 /* Register sets without using PTRACE_GETREGSET. */
819 static struct regset_info arm_regsets
[] = {
820 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0, 18 * 4,
822 arm_fill_gregset
, arm_store_gregset
},
823 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, 16 * 8 + 6 * 4,
825 arm_fill_wmmxregset
, arm_store_wmmxregset
},
826 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, 32 * 8 + 4,
828 arm_fill_vfpregset
, arm_store_vfpregset
},
832 static struct regsets_info arm_regsets_info
=
834 arm_regsets
, /* regsets */
836 NULL
, /* disabled_regsets */
839 static struct usrregs_info arm_usrregs_info
=
845 static struct regs_info regs_info_arm
=
847 NULL
, /* regset_bitmap */
852 static const struct regs_info
*
855 const struct target_desc
*tdesc
= current_process ()->tdesc
;
857 if (have_ptrace_getregset
== 1
858 && (tdesc
== tdesc_arm_with_neon
|| tdesc
== tdesc_arm_with_vfpv3
))
859 return ®s_info_aarch32
;
861 return ®s_info_arm
;
864 struct linux_target_ops the_low_target
= {
867 arm_cannot_fetch_register
,
868 arm_cannot_store_register
,
869 NULL
, /* fetch_register */
872 arm_breakpoint_kind_from_pc
,
873 arm_sw_breakpoint_from_kind
,
874 NULL
, /* get_next_pcs */
877 arm_supports_z_point_type
,
880 arm_stopped_by_watchpoint
,
881 arm_stopped_data_address
,
882 NULL
, /* collect_ptrace_register */
883 NULL
, /* supply_ptrace_register */
884 NULL
, /* siginfo_fixup */
888 arm_prepare_to_resume
,
889 NULL
, /* process_qsupported */
890 NULL
, /* supports_tracepoints */
891 NULL
, /* get_thread_area */
892 NULL
, /* install_fast_tracepoint_jump_pad */
894 NULL
, /* get_min_fast_tracepoint_insn_len */
895 NULL
, /* supports_range_stepping */
896 arm_breakpoint_kind_from_current_state
,
897 arm_supports_hardware_single_step
901 initialize_low_arch (void)
903 /* Initialize the Linux target descriptions. */
904 init_registers_arm ();
905 init_registers_arm_with_iwmmxt ();
906 init_registers_arm_with_vfpv2 ();
907 init_registers_arm_with_vfpv3 ();
909 initialize_low_arch_aarch32 ();
911 initialize_regsets_info (&arm_regsets_info
);