1 /* GNU/Linux/ARM specific low level interface, for the remote server for GDB.
2 Copyright (C) 1995-2020 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"
25 #include "linux-aarch32-tdesc.h"
26 #include "linux-arm-tdesc.h"
29 /* Don't include elf.h if linux/elf.h got included by gdb_proc_service.h.
30 On Bionic elf.h and linux/elf.h have conflicting definitions. */
34 #include "nat/gdb_ptrace.h"
36 #include <sys/syscall.h>
38 #ifndef PTRACE_GET_THREAD_AREA
39 #define PTRACE_GET_THREAD_AREA 22
42 #ifndef PTRACE_GETWMMXREGS
43 # define PTRACE_GETWMMXREGS 18
44 # define PTRACE_SETWMMXREGS 19
47 #ifndef PTRACE_GETVFPREGS
48 # define PTRACE_GETVFPREGS 27
49 # define PTRACE_SETVFPREGS 28
52 #ifndef PTRACE_GETHBPREGS
53 #define PTRACE_GETHBPREGS 29
54 #define PTRACE_SETHBPREGS 30
57 /* Linux target op definitions for the ARM architecture. */
59 class arm_target
: public linux_process_target
63 const regs_info
*get_regs_info () override
;
67 void low_arch_setup () override
;
69 bool low_cannot_fetch_register (int regno
) override
;
71 bool low_cannot_store_register (int regno
) override
;
73 bool low_supports_breakpoints () override
;
75 CORE_ADDR
low_get_pc (regcache
*regcache
) override
;
77 void low_set_pc (regcache
*regcache
, CORE_ADDR newpc
) override
;
80 /* The singleton target ops object. */
82 static arm_target the_arm_target
;
85 arm_target::low_supports_breakpoints ()
91 arm_target::low_get_pc (regcache
*regcache
)
93 return linux_get_pc_32bit (regcache
);
97 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
99 linux_set_pc_32bit (regcache
, pc
);
102 /* Information describing the hardware breakpoint capabilities. */
106 unsigned char max_wp_length
;
107 unsigned char wp_count
;
108 unsigned char bp_count
;
109 } arm_linux_hwbp_cap
;
111 /* Enum describing the different types of ARM hardware break-/watch-points. */
120 /* Type describing an ARM Hardware Breakpoint Control register value. */
121 typedef unsigned int arm_hwbp_control_t
;
123 /* Structure used to keep track of hardware break-/watch-points. */
124 struct arm_linux_hw_breakpoint
126 /* Address to break on, or being watched. */
127 unsigned int address
;
128 /* Control register for break-/watch- point. */
129 arm_hwbp_control_t control
;
132 /* Since we cannot dynamically allocate subfields of arch_process_info,
133 assume a maximum number of supported break-/watchpoints. */
137 /* Per-process arch-specific data we want to keep. */
138 struct arch_process_info
140 /* Hardware breakpoints for this process. */
141 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
142 /* Hardware watchpoints for this process. */
143 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
146 /* Per-thread arch-specific data we want to keep. */
149 /* Non-zero if our copy differs from what's recorded in the thread. */
150 char bpts_changed
[MAX_BPTS
];
151 char wpts_changed
[MAX_WPTS
];
152 /* Cached stopped data address. */
153 CORE_ADDR stopped_data_address
;
156 /* These are in <asm/elf.h> in current kernels. */
158 #define HWCAP_IWMMXT 512
159 #define HWCAP_NEON 4096
160 #define HWCAP_VFPv3 8192
161 #define HWCAP_VFPv3D16 16384
163 #ifdef HAVE_SYS_REG_H
167 #define arm_num_regs 26
169 static int arm_regmap
[] = {
170 0, 4, 8, 12, 16, 20, 24, 28,
171 32, 36, 40, 44, 48, 52, 56, 60,
172 -1, -1, -1, -1, -1, -1, -1, -1, -1,
176 /* Forward declarations needed for get_next_pcs ops. */
177 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
181 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
184 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
186 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
188 /* get_next_pcs operations. */
189 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
190 get_next_pcs_read_memory_unsigned_integer
,
191 get_next_pcs_syscall_next_pc
,
192 get_next_pcs_addr_bits_remove
,
193 get_next_pcs_is_thumb
,
194 arm_linux_get_next_pcs_fixup
,
198 arm_target::low_cannot_store_register (int regno
)
200 return (regno
>= arm_num_regs
);
204 arm_target::low_cannot_fetch_register (int regno
)
206 return (regno
>= arm_num_regs
);
210 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
212 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
215 for (int i
= 0; i
< 16; i
++)
216 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
218 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
219 for (int i
= 0; i
< 6; i
++)
220 collect_register (regcache
, arm_num_regs
+ i
+ 16,
221 (char *) buf
+ 16 * 8 + i
* 4);
225 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
227 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
230 for (int i
= 0; i
< 16; i
++)
231 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
233 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
234 for (int i
= 0; i
< 6; i
++)
235 supply_register (regcache
, arm_num_regs
+ i
+ 16,
236 (char *) buf
+ 16 * 8 + i
* 4);
240 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
244 if (is_aarch32_linux_description (regcache
->tdesc
))
248 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
250 if (fp_type
== ARM_FP_TYPE_VFPV3
)
252 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
258 arm_fill_vfpregset_num (regcache
, buf
, num
);
261 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
263 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
265 return UNMAKE_THUMB_ADDR (val
);
269 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
273 if (is_aarch32_linux_description (regcache
->tdesc
))
277 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
279 if (fp_type
== ARM_FP_TYPE_VFPV3
)
281 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
287 arm_store_vfpregset_num (regcache
, buf
, num
);
290 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
292 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
294 return arm_is_thumb_mode ();
297 /* Read memory from the inferior.
298 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
299 read_memory_unsigned_integer. */
301 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
308 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
313 /* Fetch the thread-local storage pointer for libthread_db. */
316 ps_get_thread_area (struct ps_prochandle
*ph
,
317 lwpid_t lwpid
, int idx
, void **base
)
319 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
322 /* IDX is the bias from the thread pointer to the beginning of the
323 thread descriptor. It has to be subtracted due to implementation
324 quirks in libthread_db. */
325 *base
= (void *) ((char *)*base
- idx
);
331 /* Query Hardware Breakpoint information for the target we are attached to
332 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
334 arm_linux_init_hwbp_cap (int pid
)
338 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
341 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
342 if (arm_linux_hwbp_cap
.arch
== 0)
345 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
346 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
347 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
349 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
350 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
351 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
352 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
355 /* How many hardware breakpoints are available? */
357 arm_linux_get_hw_breakpoint_count (void)
359 return arm_linux_hwbp_cap
.bp_count
;
362 /* How many hardware watchpoints are available? */
364 arm_linux_get_hw_watchpoint_count (void)
366 return arm_linux_hwbp_cap
.wp_count
;
369 /* Maximum length of area watched by hardware watchpoint. */
371 arm_linux_get_hw_watchpoint_max_length (void)
373 return arm_linux_hwbp_cap
.max_wp_length
;
376 /* Initialize an ARM hardware break-/watch-point control register value.
377 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
378 type of break-/watch-point; ENABLE indicates whether the point is enabled.
380 static arm_hwbp_control_t
381 arm_hwbp_control_initialize (unsigned byte_address_select
,
382 arm_hwbp_type hwbp_type
,
385 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
386 gdb_assert (hwbp_type
!= arm_hwbp_break
387 || ((byte_address_select
& 0xfU
) != 0));
389 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
392 /* Does the breakpoint control value CONTROL have the enable bit set? */
394 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
396 return control
& 0x1;
399 /* Is the breakpoint control value CONTROL initialized? */
401 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
406 /* Change a breakpoint control word so that it is in the disabled state. */
407 static arm_hwbp_control_t
408 arm_hwbp_control_disable (arm_hwbp_control_t control
)
410 return control
& ~0x1;
413 /* Are two break-/watch-points equal? */
415 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
416 const struct arm_linux_hw_breakpoint
*p2
)
418 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
421 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
424 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
428 case raw_bkpt_type_hw
:
429 return arm_hwbp_break
;
430 case raw_bkpt_type_write_wp
:
431 return arm_hwbp_store
;
432 case raw_bkpt_type_read_wp
:
433 return arm_hwbp_load
;
434 case raw_bkpt_type_access_wp
:
435 return arm_hwbp_access
;
437 gdb_assert_not_reached ("unhandled raw type");
441 /* Initialize the hardware breakpoint structure P for a breakpoint or
442 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
443 Returns -1 if TYPE is unsupported, or -2 if the particular combination
444 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
445 represents a breakpoint and 1 if type represents a watchpoint. */
447 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
448 int len
, struct arm_linux_hw_breakpoint
*p
)
450 arm_hwbp_type hwbp_type
;
453 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
455 if (hwbp_type
== arm_hwbp_break
)
457 /* For breakpoints, the length field encodes the mode. */
460 case 2: /* 16-bit Thumb mode breakpoint */
461 case 3: /* 32-bit Thumb mode breakpoint */
465 case 4: /* 32-bit ARM mode breakpoint */
476 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
477 CORE_ADDR aligned_addr
;
479 /* Can not set watchpoints for zero or negative lengths. */
482 /* The current ptrace interface can only handle watchpoints that are a
484 if ((len
& (len
- 1)) != 0)
487 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
488 range covered by a watchpoint. */
489 aligned_addr
= addr
& ~(max_wp_length
- 1);
490 if (aligned_addr
+ max_wp_length
< addr
+ len
)
493 mask
= (1 << len
) - 1;
496 p
->address
= (unsigned int) addr
;
497 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
499 return hwbp_type
!= arm_hwbp_break
;
502 /* Callback to mark a watch-/breakpoint to be updated in all threads of
503 the current process. */
506 update_registers_callback (thread_info
*thread
, int watch
, int i
)
508 struct lwp_info
*lwp
= get_thread_lwp (thread
);
510 /* The actual update is done later just before resuming the lwp,
511 we just mark that the registers need updating. */
513 lwp
->arch_private
->wpts_changed
[i
] = 1;
515 lwp
->arch_private
->bpts_changed
[i
] = 1;
517 /* If the lwp isn't stopped, force it to momentarily pause, so
518 we can update its breakpoint registers. */
520 linux_stop_lwp (lwp
);
524 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
))
572 /* Only update the threads of the current process. */
573 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
575 update_registers_callback (thread
, watch
, i
);
581 /* We're out of watchpoints. */
585 /* Remove hardware break-/watchpoint. */
587 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
588 int len
, struct raw_breakpoint
*bp
)
590 struct process_info
*proc
= current_process ();
591 struct arm_linux_hw_breakpoint p
, *pts
;
594 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
603 count
= arm_linux_get_hw_watchpoint_count ();
604 pts
= proc
->priv
->arch_private
->wpts
;
608 count
= arm_linux_get_hw_breakpoint_count ();
609 pts
= proc
->priv
->arch_private
->bpts
;
612 for (i
= 0; i
< count
; i
++)
613 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
615 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
617 /* Only update the threads of the current process. */
618 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
620 update_registers_callback (thread
, watch
, i
);
626 /* No watchpoint matched. */
630 /* Return whether current thread is stopped due to a watchpoint. */
632 arm_stopped_by_watchpoint (void)
634 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
637 /* We must be able to set hardware watchpoints. */
638 if (arm_linux_get_hw_watchpoint_count () == 0)
641 /* Retrieve siginfo. */
643 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
647 /* This must be a hardware breakpoint. */
648 if (siginfo
.si_signo
!= SIGTRAP
649 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
652 /* If we are in a positive slot then we're looking at a breakpoint and not
654 if (siginfo
.si_errno
>= 0)
657 /* Cache stopped data address for use by arm_stopped_data_address. */
658 lwp
->arch_private
->stopped_data_address
659 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
664 /* Return data address that triggered watchpoint. Called only if
665 arm_stopped_by_watchpoint returned true. */
667 arm_stopped_data_address (void)
669 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
670 return lwp
->arch_private
->stopped_data_address
;
673 /* Called when a new process is created. */
674 static struct arch_process_info
*
675 arm_new_process (void)
677 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
681 /* Called when a process is being deleted. */
684 arm_delete_process (struct arch_process_info
*info
)
689 /* Called when a new thread is detected. */
691 arm_new_thread (struct lwp_info
*lwp
)
693 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
696 for (i
= 0; i
< MAX_BPTS
; i
++)
697 info
->bpts_changed
[i
] = 1;
698 for (i
= 0; i
< MAX_WPTS
; i
++)
699 info
->wpts_changed
[i
] = 1;
701 lwp
->arch_private
= info
;
704 /* Function to call when a thread is being deleted. */
707 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
713 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
715 struct arch_process_info
*parent_proc_info
;
716 struct arch_process_info
*child_proc_info
;
717 struct lwp_info
*child_lwp
;
718 struct arch_lwp_info
*child_lwp_info
;
721 /* These are allocated by linux_add_process. */
722 gdb_assert (parent
->priv
!= NULL
723 && parent
->priv
->arch_private
!= NULL
);
724 gdb_assert (child
->priv
!= NULL
725 && child
->priv
->arch_private
!= NULL
);
727 parent_proc_info
= parent
->priv
->arch_private
;
728 child_proc_info
= child
->priv
->arch_private
;
730 /* Linux kernel before 2.6.33 commit
731 72f674d203cd230426437cdcf7dd6f681dad8b0d
732 will inherit hardware debug registers from parent
733 on fork/vfork/clone. Newer Linux kernels create such tasks with
734 zeroed debug registers.
736 GDB core assumes the child inherits the watchpoints/hw
737 breakpoints of the parent, and will remove them all from the
738 forked off process. Copy the debug registers mirrors into the
739 new process so that all breakpoints and watchpoints can be
740 removed together. The debug registers mirror will become zeroed
741 in the end before detaching the forked off process, thus making
742 this compatible with older Linux kernels too. */
744 *child_proc_info
= *parent_proc_info
;
746 /* Mark all the hardware breakpoints and watchpoints as changed to
747 make sure that the registers will be updated. */
748 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
749 child_lwp_info
= child_lwp
->arch_private
;
750 for (i
= 0; i
< MAX_BPTS
; i
++)
751 child_lwp_info
->bpts_changed
[i
] = 1;
752 for (i
= 0; i
< MAX_WPTS
; i
++)
753 child_lwp_info
->wpts_changed
[i
] = 1;
756 /* Called when resuming a thread.
757 If the debug regs have changed, update the thread's copies. */
759 arm_prepare_to_resume (struct lwp_info
*lwp
)
761 struct thread_info
*thread
= get_lwp_thread (lwp
);
762 int pid
= lwpid_of (thread
);
763 struct process_info
*proc
= find_process_pid (pid_of (thread
));
764 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
765 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
768 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
769 if (lwp_info
->bpts_changed
[i
])
773 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
774 if (ptrace (PTRACE_SETHBPREGS
, pid
,
775 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
776 &proc_info
->bpts
[i
].address
) < 0)
777 perror_with_name ("Unexpected error setting breakpoint address");
779 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
780 if (ptrace (PTRACE_SETHBPREGS
, pid
,
781 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
782 &proc_info
->bpts
[i
].control
) < 0)
783 perror_with_name ("Unexpected error setting breakpoint");
785 lwp_info
->bpts_changed
[i
] = 0;
788 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
789 if (lwp_info
->wpts_changed
[i
])
793 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
794 if (ptrace (PTRACE_SETHBPREGS
, pid
,
795 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
796 &proc_info
->wpts
[i
].address
) < 0)
797 perror_with_name ("Unexpected error setting watchpoint address");
799 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
800 if (ptrace (PTRACE_SETHBPREGS
, pid
,
801 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
802 &proc_info
->wpts
[i
].control
) < 0)
803 perror_with_name ("Unexpected error setting watchpoint");
805 lwp_info
->wpts_changed
[i
] = 0;
809 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
810 addition, set IS_THUMB depending on whether we will return to ARM
812 See arm-linux.h for stack layout details. */
814 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
818 unsigned long sp_data
;
819 /* Offset of PC register. */
821 CORE_ADDR next_pc
= 0;
824 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
826 collect_register_by_name (regcache
, "sp", &sp
);
827 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
829 pc_offset
= arm_linux_sigreturn_next_pc_offset
830 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
832 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
834 /* Set IS_THUMB according the CPSR saved on the stack. */
835 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
836 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
841 /* When PC is at a syscall instruction, return the PC of the next
842 instruction to be executed. */
844 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
846 CORE_ADDR next_pc
= 0;
847 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
848 int is_thumb
= arm_is_thumb_mode ();
849 ULONGEST svc_number
= 0;
850 struct regcache
*regcache
= self
->regcache
;
854 collect_register (regcache
, 7, &svc_number
);
859 unsigned long this_instr
;
860 unsigned long svc_operand
;
862 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
863 svc_operand
= (0x00ffffff & this_instr
);
865 if (svc_operand
) /* OABI. */
867 svc_number
= svc_operand
- 0x900000;
871 collect_register (regcache
, 7, &svc_number
);
877 /* This is a sigreturn or sigreturn_rt syscall. */
878 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
880 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
882 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
885 /* Addresses for calling Thumb functions have the bit 0 set. */
887 next_pc
= MAKE_THUMB_ADDR (next_pc
);
892 static const struct target_desc
*
893 arm_read_description (void)
895 unsigned long arm_hwcap
= linux_get_hwcap (4);
897 if (arm_hwcap
& HWCAP_IWMMXT
)
898 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
900 if (arm_hwcap
& HWCAP_VFP
)
902 /* Make sure that the kernel supports reading VFP registers. Support was
904 int pid
= lwpid_of (current_thread
);
906 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
907 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
908 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
910 /* NEON implies either no VFP, or VFPv3-D32. We only support
912 if (arm_hwcap
& HWCAP_NEON
)
913 return aarch32_linux_read_description ();
914 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
915 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
917 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
920 /* The default configuration uses legacy FPA registers, probably
922 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
926 arm_target::low_arch_setup ()
928 int tid
= lwpid_of (current_thread
);
932 /* Query hardware watchpoint/breakpoint capabilities. */
933 arm_linux_init_hwbp_cap (tid
);
935 current_process ()->tdesc
= arm_read_description ();
937 iov
.iov_base
= gpregs
;
938 iov
.iov_len
= sizeof (gpregs
);
940 /* Check if PTRACE_GETREGSET works. */
941 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
942 have_ptrace_getregset
= 1;
944 have_ptrace_getregset
= 0;
947 /* Fetch the next possible PCs after the current instruction executes. */
949 static std::vector
<CORE_ADDR
>
950 arm_gdbserver_get_next_pcs (struct regcache
*regcache
)
952 struct arm_get_next_pcs next_pcs_ctx
;
954 arm_get_next_pcs_ctor (&next_pcs_ctx
,
956 /* Byte order is ignored assumed as host. */
962 return arm_get_next_pcs (&next_pcs_ctx
);
965 /* Support for hardware single step. */
968 arm_supports_hardware_single_step (void)
973 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
976 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
978 if (arm_is_thumb_mode ())
979 collect_register_by_name (regcache
, "r7", sysno
);
985 collect_register_by_name (regcache
, "pc", &pc
);
987 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
988 *sysno
= UNKNOWN_SYSCALL
;
991 unsigned long svc_operand
= (0x00ffffff & insn
);
996 *sysno
= svc_operand
- 0x900000;
1001 collect_register_by_name (regcache
, "r7", sysno
);
1007 /* Register sets without using PTRACE_GETREGSET. */
1009 static struct regset_info arm_regsets
[] = {
1010 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1011 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1012 arm_fill_gregset
, arm_store_gregset
},
1013 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1014 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1015 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1016 arm_fill_vfpregset
, arm_store_vfpregset
},
1020 static struct regsets_info arm_regsets_info
=
1022 arm_regsets
, /* regsets */
1023 0, /* num_regsets */
1024 NULL
, /* disabled_regsets */
1027 static struct usrregs_info arm_usrregs_info
=
1033 static struct regs_info regs_info_arm
=
1035 NULL
, /* regset_bitmap */
1041 arm_target::get_regs_info ()
1043 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1045 if (have_ptrace_getregset
== 1
1046 && (is_aarch32_linux_description (tdesc
)
1047 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1048 return ®s_info_aarch32
;
1050 return ®s_info_arm
;
1053 struct linux_target_ops the_low_target
= {
1054 arm_breakpoint_kind_from_pc
,
1055 arm_sw_breakpoint_from_kind
,
1056 arm_gdbserver_get_next_pcs
,
1059 arm_supports_z_point_type
,
1062 arm_stopped_by_watchpoint
,
1063 arm_stopped_data_address
,
1064 NULL
, /* collect_ptrace_register */
1065 NULL
, /* supply_ptrace_register */
1066 NULL
, /* siginfo_fixup */
1072 arm_prepare_to_resume
,
1073 NULL
, /* process_qsupported */
1074 NULL
, /* supports_tracepoints */
1075 NULL
, /* get_thread_area */
1076 NULL
, /* install_fast_tracepoint_jump_pad */
1077 NULL
, /* emit_ops */
1078 NULL
, /* get_min_fast_tracepoint_insn_len */
1079 NULL
, /* supports_range_stepping */
1080 arm_breakpoint_kind_from_current_state
,
1081 arm_supports_hardware_single_step
,
1082 arm_get_syscall_trapinfo
,
1085 /* The linux target ops object. */
1087 linux_process_target
*the_linux_target
= &the_arm_target
;
1090 initialize_low_arch (void)
1092 initialize_low_arch_aarch32 ();
1093 initialize_regsets_info (&arm_regsets_info
);