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
;
65 int breakpoint_kind_from_pc (CORE_ADDR
*pcptr
) override
;
67 int breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
) override
;
69 const gdb_byte
*sw_breakpoint_from_kind (int kind
, int *size
) override
;
71 bool supports_software_single_step () override
;
75 void low_arch_setup () override
;
77 bool low_cannot_fetch_register (int regno
) override
;
79 bool low_cannot_store_register (int regno
) override
;
81 bool low_supports_breakpoints () override
;
83 CORE_ADDR
low_get_pc (regcache
*regcache
) override
;
85 void low_set_pc (regcache
*regcache
, CORE_ADDR newpc
) override
;
87 std::vector
<CORE_ADDR
> low_get_next_pcs (regcache
*regcache
) override
;
90 /* The singleton target ops object. */
92 static arm_target the_arm_target
;
95 arm_target::low_supports_breakpoints ()
101 arm_target::low_get_pc (regcache
*regcache
)
103 return linux_get_pc_32bit (regcache
);
107 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
109 linux_set_pc_32bit (regcache
, pc
);
113 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
115 return arm_breakpoint_kind_from_pc (pcptr
);
119 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
121 return arm_breakpoint_kind_from_current_state (pcptr
);
125 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
127 return arm_sw_breakpoint_from_kind (kind
, size
);
130 /* Information describing the hardware breakpoint capabilities. */
134 unsigned char max_wp_length
;
135 unsigned char wp_count
;
136 unsigned char bp_count
;
137 } arm_linux_hwbp_cap
;
139 /* Enum describing the different types of ARM hardware break-/watch-points. */
148 /* Type describing an ARM Hardware Breakpoint Control register value. */
149 typedef unsigned int arm_hwbp_control_t
;
151 /* Structure used to keep track of hardware break-/watch-points. */
152 struct arm_linux_hw_breakpoint
154 /* Address to break on, or being watched. */
155 unsigned int address
;
156 /* Control register for break-/watch- point. */
157 arm_hwbp_control_t control
;
160 /* Since we cannot dynamically allocate subfields of arch_process_info,
161 assume a maximum number of supported break-/watchpoints. */
165 /* Per-process arch-specific data we want to keep. */
166 struct arch_process_info
168 /* Hardware breakpoints for this process. */
169 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
170 /* Hardware watchpoints for this process. */
171 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
174 /* Per-thread arch-specific data we want to keep. */
177 /* Non-zero if our copy differs from what's recorded in the thread. */
178 char bpts_changed
[MAX_BPTS
];
179 char wpts_changed
[MAX_WPTS
];
180 /* Cached stopped data address. */
181 CORE_ADDR stopped_data_address
;
184 /* These are in <asm/elf.h> in current kernels. */
186 #define HWCAP_IWMMXT 512
187 #define HWCAP_NEON 4096
188 #define HWCAP_VFPv3 8192
189 #define HWCAP_VFPv3D16 16384
191 #ifdef HAVE_SYS_REG_H
195 #define arm_num_regs 26
197 static int arm_regmap
[] = {
198 0, 4, 8, 12, 16, 20, 24, 28,
199 32, 36, 40, 44, 48, 52, 56, 60,
200 -1, -1, -1, -1, -1, -1, -1, -1, -1,
204 /* Forward declarations needed for get_next_pcs ops. */
205 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
209 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
212 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
214 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
216 /* get_next_pcs operations. */
217 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
218 get_next_pcs_read_memory_unsigned_integer
,
219 get_next_pcs_syscall_next_pc
,
220 get_next_pcs_addr_bits_remove
,
221 get_next_pcs_is_thumb
,
222 arm_linux_get_next_pcs_fixup
,
226 arm_target::low_cannot_store_register (int regno
)
228 return (regno
>= arm_num_regs
);
232 arm_target::low_cannot_fetch_register (int regno
)
234 return (regno
>= arm_num_regs
);
238 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
240 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
243 for (int i
= 0; i
< 16; i
++)
244 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
246 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
247 for (int i
= 0; i
< 6; i
++)
248 collect_register (regcache
, arm_num_regs
+ i
+ 16,
249 (char *) buf
+ 16 * 8 + i
* 4);
253 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
255 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
258 for (int i
= 0; i
< 16; i
++)
259 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
261 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
262 for (int i
= 0; i
< 6; i
++)
263 supply_register (regcache
, arm_num_regs
+ i
+ 16,
264 (char *) buf
+ 16 * 8 + i
* 4);
268 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
272 if (is_aarch32_linux_description (regcache
->tdesc
))
276 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
278 if (fp_type
== ARM_FP_TYPE_VFPV3
)
280 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
286 arm_fill_vfpregset_num (regcache
, buf
, num
);
289 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
291 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
293 return UNMAKE_THUMB_ADDR (val
);
297 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
301 if (is_aarch32_linux_description (regcache
->tdesc
))
305 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
307 if (fp_type
== ARM_FP_TYPE_VFPV3
)
309 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
315 arm_store_vfpregset_num (regcache
, buf
, num
);
318 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
320 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
322 return arm_is_thumb_mode ();
325 /* Read memory from the inferior.
326 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
327 read_memory_unsigned_integer. */
329 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
336 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
341 /* Fetch the thread-local storage pointer for libthread_db. */
344 ps_get_thread_area (struct ps_prochandle
*ph
,
345 lwpid_t lwpid
, int idx
, void **base
)
347 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
350 /* IDX is the bias from the thread pointer to the beginning of the
351 thread descriptor. It has to be subtracted due to implementation
352 quirks in libthread_db. */
353 *base
= (void *) ((char *)*base
- idx
);
359 /* Query Hardware Breakpoint information for the target we are attached to
360 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
362 arm_linux_init_hwbp_cap (int pid
)
366 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
369 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
370 if (arm_linux_hwbp_cap
.arch
== 0)
373 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
374 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
375 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
377 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
378 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
379 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
380 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
383 /* How many hardware breakpoints are available? */
385 arm_linux_get_hw_breakpoint_count (void)
387 return arm_linux_hwbp_cap
.bp_count
;
390 /* How many hardware watchpoints are available? */
392 arm_linux_get_hw_watchpoint_count (void)
394 return arm_linux_hwbp_cap
.wp_count
;
397 /* Maximum length of area watched by hardware watchpoint. */
399 arm_linux_get_hw_watchpoint_max_length (void)
401 return arm_linux_hwbp_cap
.max_wp_length
;
404 /* Initialize an ARM hardware break-/watch-point control register value.
405 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
406 type of break-/watch-point; ENABLE indicates whether the point is enabled.
408 static arm_hwbp_control_t
409 arm_hwbp_control_initialize (unsigned byte_address_select
,
410 arm_hwbp_type hwbp_type
,
413 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
414 gdb_assert (hwbp_type
!= arm_hwbp_break
415 || ((byte_address_select
& 0xfU
) != 0));
417 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
420 /* Does the breakpoint control value CONTROL have the enable bit set? */
422 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
424 return control
& 0x1;
427 /* Is the breakpoint control value CONTROL initialized? */
429 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
434 /* Change a breakpoint control word so that it is in the disabled state. */
435 static arm_hwbp_control_t
436 arm_hwbp_control_disable (arm_hwbp_control_t control
)
438 return control
& ~0x1;
441 /* Are two break-/watch-points equal? */
443 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
444 const struct arm_linux_hw_breakpoint
*p2
)
446 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
449 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
452 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
456 case raw_bkpt_type_hw
:
457 return arm_hwbp_break
;
458 case raw_bkpt_type_write_wp
:
459 return arm_hwbp_store
;
460 case raw_bkpt_type_read_wp
:
461 return arm_hwbp_load
;
462 case raw_bkpt_type_access_wp
:
463 return arm_hwbp_access
;
465 gdb_assert_not_reached ("unhandled raw type");
469 /* Initialize the hardware breakpoint structure P for a breakpoint or
470 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
471 Returns -1 if TYPE is unsupported, or -2 if the particular combination
472 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
473 represents a breakpoint and 1 if type represents a watchpoint. */
475 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
476 int len
, struct arm_linux_hw_breakpoint
*p
)
478 arm_hwbp_type hwbp_type
;
481 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
483 if (hwbp_type
== arm_hwbp_break
)
485 /* For breakpoints, the length field encodes the mode. */
488 case 2: /* 16-bit Thumb mode breakpoint */
489 case 3: /* 32-bit Thumb mode breakpoint */
493 case 4: /* 32-bit ARM mode breakpoint */
504 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
505 CORE_ADDR aligned_addr
;
507 /* Can not set watchpoints for zero or negative lengths. */
510 /* The current ptrace interface can only handle watchpoints that are a
512 if ((len
& (len
- 1)) != 0)
515 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
516 range covered by a watchpoint. */
517 aligned_addr
= addr
& ~(max_wp_length
- 1);
518 if (aligned_addr
+ max_wp_length
< addr
+ len
)
521 mask
= (1 << len
) - 1;
524 p
->address
= (unsigned int) addr
;
525 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
527 return hwbp_type
!= arm_hwbp_break
;
530 /* Callback to mark a watch-/breakpoint to be updated in all threads of
531 the current process. */
534 update_registers_callback (thread_info
*thread
, int watch
, int i
)
536 struct lwp_info
*lwp
= get_thread_lwp (thread
);
538 /* The actual update is done later just before resuming the lwp,
539 we just mark that the registers need updating. */
541 lwp
->arch_private
->wpts_changed
[i
] = 1;
543 lwp
->arch_private
->bpts_changed
[i
] = 1;
545 /* If the lwp isn't stopped, force it to momentarily pause, so
546 we can update its breakpoint registers. */
548 linux_stop_lwp (lwp
);
552 arm_supports_z_point_type (char z_type
)
558 case Z_PACKET_WRITE_WP
:
559 case Z_PACKET_READ_WP
:
560 case Z_PACKET_ACCESS_WP
:
563 /* Leave the handling of sw breakpoints with the gdb client. */
568 /* Insert hardware break-/watchpoint. */
570 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
571 int len
, struct raw_breakpoint
*bp
)
573 struct process_info
*proc
= current_process ();
574 struct arm_linux_hw_breakpoint p
, *pts
;
577 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
581 return watch
== -1 ? 1 : -1;
586 count
= arm_linux_get_hw_watchpoint_count ();
587 pts
= proc
->priv
->arch_private
->wpts
;
591 count
= arm_linux_get_hw_breakpoint_count ();
592 pts
= proc
->priv
->arch_private
->bpts
;
595 for (i
= 0; i
< count
; i
++)
596 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
600 /* Only update the threads of the current process. */
601 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
603 update_registers_callback (thread
, watch
, i
);
609 /* We're out of watchpoints. */
613 /* Remove hardware break-/watchpoint. */
615 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
616 int len
, struct raw_breakpoint
*bp
)
618 struct process_info
*proc
= current_process ();
619 struct arm_linux_hw_breakpoint p
, *pts
;
622 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
631 count
= arm_linux_get_hw_watchpoint_count ();
632 pts
= proc
->priv
->arch_private
->wpts
;
636 count
= arm_linux_get_hw_breakpoint_count ();
637 pts
= proc
->priv
->arch_private
->bpts
;
640 for (i
= 0; i
< count
; i
++)
641 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
643 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
645 /* Only update the threads of the current process. */
646 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
648 update_registers_callback (thread
, watch
, i
);
654 /* No watchpoint matched. */
658 /* Return whether current thread is stopped due to a watchpoint. */
660 arm_stopped_by_watchpoint (void)
662 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
665 /* We must be able to set hardware watchpoints. */
666 if (arm_linux_get_hw_watchpoint_count () == 0)
669 /* Retrieve siginfo. */
671 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
675 /* This must be a hardware breakpoint. */
676 if (siginfo
.si_signo
!= SIGTRAP
677 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
680 /* If we are in a positive slot then we're looking at a breakpoint and not
682 if (siginfo
.si_errno
>= 0)
685 /* Cache stopped data address for use by arm_stopped_data_address. */
686 lwp
->arch_private
->stopped_data_address
687 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
692 /* Return data address that triggered watchpoint. Called only if
693 arm_stopped_by_watchpoint returned true. */
695 arm_stopped_data_address (void)
697 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
698 return lwp
->arch_private
->stopped_data_address
;
701 /* Called when a new process is created. */
702 static struct arch_process_info
*
703 arm_new_process (void)
705 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
709 /* Called when a process is being deleted. */
712 arm_delete_process (struct arch_process_info
*info
)
717 /* Called when a new thread is detected. */
719 arm_new_thread (struct lwp_info
*lwp
)
721 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
724 for (i
= 0; i
< MAX_BPTS
; i
++)
725 info
->bpts_changed
[i
] = 1;
726 for (i
= 0; i
< MAX_WPTS
; i
++)
727 info
->wpts_changed
[i
] = 1;
729 lwp
->arch_private
= info
;
732 /* Function to call when a thread is being deleted. */
735 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
741 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
743 struct arch_process_info
*parent_proc_info
;
744 struct arch_process_info
*child_proc_info
;
745 struct lwp_info
*child_lwp
;
746 struct arch_lwp_info
*child_lwp_info
;
749 /* These are allocated by linux_add_process. */
750 gdb_assert (parent
->priv
!= NULL
751 && parent
->priv
->arch_private
!= NULL
);
752 gdb_assert (child
->priv
!= NULL
753 && child
->priv
->arch_private
!= NULL
);
755 parent_proc_info
= parent
->priv
->arch_private
;
756 child_proc_info
= child
->priv
->arch_private
;
758 /* Linux kernel before 2.6.33 commit
759 72f674d203cd230426437cdcf7dd6f681dad8b0d
760 will inherit hardware debug registers from parent
761 on fork/vfork/clone. Newer Linux kernels create such tasks with
762 zeroed debug registers.
764 GDB core assumes the child inherits the watchpoints/hw
765 breakpoints of the parent, and will remove them all from the
766 forked off process. Copy the debug registers mirrors into the
767 new process so that all breakpoints and watchpoints can be
768 removed together. The debug registers mirror will become zeroed
769 in the end before detaching the forked off process, thus making
770 this compatible with older Linux kernels too. */
772 *child_proc_info
= *parent_proc_info
;
774 /* Mark all the hardware breakpoints and watchpoints as changed to
775 make sure that the registers will be updated. */
776 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
777 child_lwp_info
= child_lwp
->arch_private
;
778 for (i
= 0; i
< MAX_BPTS
; i
++)
779 child_lwp_info
->bpts_changed
[i
] = 1;
780 for (i
= 0; i
< MAX_WPTS
; i
++)
781 child_lwp_info
->wpts_changed
[i
] = 1;
784 /* Called when resuming a thread.
785 If the debug regs have changed, update the thread's copies. */
787 arm_prepare_to_resume (struct lwp_info
*lwp
)
789 struct thread_info
*thread
= get_lwp_thread (lwp
);
790 int pid
= lwpid_of (thread
);
791 struct process_info
*proc
= find_process_pid (pid_of (thread
));
792 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
793 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
796 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
797 if (lwp_info
->bpts_changed
[i
])
801 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
802 if (ptrace (PTRACE_SETHBPREGS
, pid
,
803 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
804 &proc_info
->bpts
[i
].address
) < 0)
805 perror_with_name ("Unexpected error setting breakpoint address");
807 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
808 if (ptrace (PTRACE_SETHBPREGS
, pid
,
809 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
810 &proc_info
->bpts
[i
].control
) < 0)
811 perror_with_name ("Unexpected error setting breakpoint");
813 lwp_info
->bpts_changed
[i
] = 0;
816 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
817 if (lwp_info
->wpts_changed
[i
])
821 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
822 if (ptrace (PTRACE_SETHBPREGS
, pid
,
823 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
824 &proc_info
->wpts
[i
].address
) < 0)
825 perror_with_name ("Unexpected error setting watchpoint address");
827 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
828 if (ptrace (PTRACE_SETHBPREGS
, pid
,
829 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
830 &proc_info
->wpts
[i
].control
) < 0)
831 perror_with_name ("Unexpected error setting watchpoint");
833 lwp_info
->wpts_changed
[i
] = 0;
837 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
838 addition, set IS_THUMB depending on whether we will return to ARM
840 See arm-linux.h for stack layout details. */
842 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
846 unsigned long sp_data
;
847 /* Offset of PC register. */
849 CORE_ADDR next_pc
= 0;
852 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
854 collect_register_by_name (regcache
, "sp", &sp
);
855 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
857 pc_offset
= arm_linux_sigreturn_next_pc_offset
858 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
860 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
862 /* Set IS_THUMB according the CPSR saved on the stack. */
863 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
864 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
869 /* When PC is at a syscall instruction, return the PC of the next
870 instruction to be executed. */
872 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
874 CORE_ADDR next_pc
= 0;
875 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
876 int is_thumb
= arm_is_thumb_mode ();
877 ULONGEST svc_number
= 0;
878 struct regcache
*regcache
= self
->regcache
;
882 collect_register (regcache
, 7, &svc_number
);
887 unsigned long this_instr
;
888 unsigned long svc_operand
;
890 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
891 svc_operand
= (0x00ffffff & this_instr
);
893 if (svc_operand
) /* OABI. */
895 svc_number
= svc_operand
- 0x900000;
899 collect_register (regcache
, 7, &svc_number
);
905 /* This is a sigreturn or sigreturn_rt syscall. */
906 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
908 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
910 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
913 /* Addresses for calling Thumb functions have the bit 0 set. */
915 next_pc
= MAKE_THUMB_ADDR (next_pc
);
920 static const struct target_desc
*
921 arm_read_description (void)
923 unsigned long arm_hwcap
= linux_get_hwcap (4);
925 if (arm_hwcap
& HWCAP_IWMMXT
)
926 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
928 if (arm_hwcap
& HWCAP_VFP
)
930 /* Make sure that the kernel supports reading VFP registers. Support was
932 int pid
= lwpid_of (current_thread
);
934 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
935 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
936 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
938 /* NEON implies either no VFP, or VFPv3-D32. We only support
940 if (arm_hwcap
& HWCAP_NEON
)
941 return aarch32_linux_read_description ();
942 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
943 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
945 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
948 /* The default configuration uses legacy FPA registers, probably
950 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
954 arm_target::low_arch_setup ()
956 int tid
= lwpid_of (current_thread
);
960 /* Query hardware watchpoint/breakpoint capabilities. */
961 arm_linux_init_hwbp_cap (tid
);
963 current_process ()->tdesc
= arm_read_description ();
965 iov
.iov_base
= gpregs
;
966 iov
.iov_len
= sizeof (gpregs
);
968 /* Check if PTRACE_GETREGSET works. */
969 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
970 have_ptrace_getregset
= 1;
972 have_ptrace_getregset
= 0;
976 arm_target::supports_software_single_step ()
981 /* Fetch the next possible PCs after the current instruction executes. */
983 std::vector
<CORE_ADDR
>
984 arm_target::low_get_next_pcs (regcache
*regcache
)
986 struct arm_get_next_pcs next_pcs_ctx
;
988 arm_get_next_pcs_ctor (&next_pcs_ctx
,
990 /* Byte order is ignored assumed as host. */
996 return arm_get_next_pcs (&next_pcs_ctx
);
999 /* Support for hardware single step. */
1002 arm_supports_hardware_single_step (void)
1007 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1010 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1012 if (arm_is_thumb_mode ())
1013 collect_register_by_name (regcache
, "r7", sysno
);
1019 collect_register_by_name (regcache
, "pc", &pc
);
1021 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1022 *sysno
= UNKNOWN_SYSCALL
;
1025 unsigned long svc_operand
= (0x00ffffff & insn
);
1030 *sysno
= svc_operand
- 0x900000;
1035 collect_register_by_name (regcache
, "r7", sysno
);
1041 /* Register sets without using PTRACE_GETREGSET. */
1043 static struct regset_info arm_regsets
[] = {
1044 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1045 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1046 arm_fill_gregset
, arm_store_gregset
},
1047 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1048 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1049 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1050 arm_fill_vfpregset
, arm_store_vfpregset
},
1054 static struct regsets_info arm_regsets_info
=
1056 arm_regsets
, /* regsets */
1057 0, /* num_regsets */
1058 NULL
, /* disabled_regsets */
1061 static struct usrregs_info arm_usrregs_info
=
1067 static struct regs_info regs_info_arm
=
1069 NULL
, /* regset_bitmap */
1075 arm_target::get_regs_info ()
1077 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1079 if (have_ptrace_getregset
== 1
1080 && (is_aarch32_linux_description (tdesc
)
1081 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1082 return ®s_info_aarch32
;
1084 return ®s_info_arm
;
1087 struct linux_target_ops the_low_target
= {
1090 arm_supports_z_point_type
,
1093 arm_stopped_by_watchpoint
,
1094 arm_stopped_data_address
,
1095 NULL
, /* collect_ptrace_register */
1096 NULL
, /* supply_ptrace_register */
1097 NULL
, /* siginfo_fixup */
1103 arm_prepare_to_resume
,
1104 NULL
, /* process_qsupported */
1105 NULL
, /* supports_tracepoints */
1106 NULL
, /* get_thread_area */
1107 NULL
, /* install_fast_tracepoint_jump_pad */
1108 NULL
, /* emit_ops */
1109 NULL
, /* get_min_fast_tracepoint_insn_len */
1110 NULL
, /* supports_range_stepping */
1111 arm_supports_hardware_single_step
,
1112 arm_get_syscall_trapinfo
,
1115 /* The linux target ops object. */
1117 linux_process_target
*the_linux_target
= &the_arm_target
;
1120 initialize_low_arch (void)
1122 initialize_low_arch_aarch32 ();
1123 initialize_regsets_info (&arm_regsets_info
);