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
;
89 bool low_breakpoint_at (CORE_ADDR pc
) override
;
92 /* The singleton target ops object. */
94 static arm_target the_arm_target
;
97 arm_target::low_supports_breakpoints ()
103 arm_target::low_get_pc (regcache
*regcache
)
105 return linux_get_pc_32bit (regcache
);
109 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
111 linux_set_pc_32bit (regcache
, pc
);
115 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
117 return arm_breakpoint_kind_from_pc (pcptr
);
121 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
123 return arm_breakpoint_kind_from_current_state (pcptr
);
127 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
129 return arm_sw_breakpoint_from_kind (kind
, size
);
133 arm_target::low_breakpoint_at (CORE_ADDR pc
)
135 return arm_breakpoint_at (pc
);
138 /* Information describing the hardware breakpoint capabilities. */
142 unsigned char max_wp_length
;
143 unsigned char wp_count
;
144 unsigned char bp_count
;
145 } arm_linux_hwbp_cap
;
147 /* Enum describing the different types of ARM hardware break-/watch-points. */
156 /* Type describing an ARM Hardware Breakpoint Control register value. */
157 typedef unsigned int arm_hwbp_control_t
;
159 /* Structure used to keep track of hardware break-/watch-points. */
160 struct arm_linux_hw_breakpoint
162 /* Address to break on, or being watched. */
163 unsigned int address
;
164 /* Control register for break-/watch- point. */
165 arm_hwbp_control_t control
;
168 /* Since we cannot dynamically allocate subfields of arch_process_info,
169 assume a maximum number of supported break-/watchpoints. */
173 /* Per-process arch-specific data we want to keep. */
174 struct arch_process_info
176 /* Hardware breakpoints for this process. */
177 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
178 /* Hardware watchpoints for this process. */
179 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
182 /* Per-thread arch-specific data we want to keep. */
185 /* Non-zero if our copy differs from what's recorded in the thread. */
186 char bpts_changed
[MAX_BPTS
];
187 char wpts_changed
[MAX_WPTS
];
188 /* Cached stopped data address. */
189 CORE_ADDR stopped_data_address
;
192 /* These are in <asm/elf.h> in current kernels. */
194 #define HWCAP_IWMMXT 512
195 #define HWCAP_NEON 4096
196 #define HWCAP_VFPv3 8192
197 #define HWCAP_VFPv3D16 16384
199 #ifdef HAVE_SYS_REG_H
203 #define arm_num_regs 26
205 static int arm_regmap
[] = {
206 0, 4, 8, 12, 16, 20, 24, 28,
207 32, 36, 40, 44, 48, 52, 56, 60,
208 -1, -1, -1, -1, -1, -1, -1, -1, -1,
212 /* Forward declarations needed for get_next_pcs ops. */
213 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
217 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
220 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
222 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
224 /* get_next_pcs operations. */
225 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
226 get_next_pcs_read_memory_unsigned_integer
,
227 get_next_pcs_syscall_next_pc
,
228 get_next_pcs_addr_bits_remove
,
229 get_next_pcs_is_thumb
,
230 arm_linux_get_next_pcs_fixup
,
234 arm_target::low_cannot_store_register (int regno
)
236 return (regno
>= arm_num_regs
);
240 arm_target::low_cannot_fetch_register (int regno
)
242 return (regno
>= arm_num_regs
);
246 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
248 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
251 for (int i
= 0; i
< 16; i
++)
252 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
254 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
255 for (int i
= 0; i
< 6; i
++)
256 collect_register (regcache
, arm_num_regs
+ i
+ 16,
257 (char *) buf
+ 16 * 8 + i
* 4);
261 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
263 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
266 for (int i
= 0; i
< 16; i
++)
267 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
269 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
270 for (int i
= 0; i
< 6; i
++)
271 supply_register (regcache
, arm_num_regs
+ i
+ 16,
272 (char *) buf
+ 16 * 8 + i
* 4);
276 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
280 if (is_aarch32_linux_description (regcache
->tdesc
))
284 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
286 if (fp_type
== ARM_FP_TYPE_VFPV3
)
288 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
294 arm_fill_vfpregset_num (regcache
, buf
, num
);
297 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
299 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
301 return UNMAKE_THUMB_ADDR (val
);
305 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
309 if (is_aarch32_linux_description (regcache
->tdesc
))
313 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
315 if (fp_type
== ARM_FP_TYPE_VFPV3
)
317 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
323 arm_store_vfpregset_num (regcache
, buf
, num
);
326 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
328 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
330 return arm_is_thumb_mode ();
333 /* Read memory from the inferior.
334 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
335 read_memory_unsigned_integer. */
337 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
344 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
349 /* Fetch the thread-local storage pointer for libthread_db. */
352 ps_get_thread_area (struct ps_prochandle
*ph
,
353 lwpid_t lwpid
, int idx
, void **base
)
355 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
358 /* IDX is the bias from the thread pointer to the beginning of the
359 thread descriptor. It has to be subtracted due to implementation
360 quirks in libthread_db. */
361 *base
= (void *) ((char *)*base
- idx
);
367 /* Query Hardware Breakpoint information for the target we are attached to
368 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
370 arm_linux_init_hwbp_cap (int pid
)
374 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
377 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
378 if (arm_linux_hwbp_cap
.arch
== 0)
381 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
382 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
383 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
385 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
386 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
387 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
388 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
391 /* How many hardware breakpoints are available? */
393 arm_linux_get_hw_breakpoint_count (void)
395 return arm_linux_hwbp_cap
.bp_count
;
398 /* How many hardware watchpoints are available? */
400 arm_linux_get_hw_watchpoint_count (void)
402 return arm_linux_hwbp_cap
.wp_count
;
405 /* Maximum length of area watched by hardware watchpoint. */
407 arm_linux_get_hw_watchpoint_max_length (void)
409 return arm_linux_hwbp_cap
.max_wp_length
;
412 /* Initialize an ARM hardware break-/watch-point control register value.
413 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
414 type of break-/watch-point; ENABLE indicates whether the point is enabled.
416 static arm_hwbp_control_t
417 arm_hwbp_control_initialize (unsigned byte_address_select
,
418 arm_hwbp_type hwbp_type
,
421 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
422 gdb_assert (hwbp_type
!= arm_hwbp_break
423 || ((byte_address_select
& 0xfU
) != 0));
425 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
428 /* Does the breakpoint control value CONTROL have the enable bit set? */
430 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
432 return control
& 0x1;
435 /* Is the breakpoint control value CONTROL initialized? */
437 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
442 /* Change a breakpoint control word so that it is in the disabled state. */
443 static arm_hwbp_control_t
444 arm_hwbp_control_disable (arm_hwbp_control_t control
)
446 return control
& ~0x1;
449 /* Are two break-/watch-points equal? */
451 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
452 const struct arm_linux_hw_breakpoint
*p2
)
454 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
457 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
460 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
464 case raw_bkpt_type_hw
:
465 return arm_hwbp_break
;
466 case raw_bkpt_type_write_wp
:
467 return arm_hwbp_store
;
468 case raw_bkpt_type_read_wp
:
469 return arm_hwbp_load
;
470 case raw_bkpt_type_access_wp
:
471 return arm_hwbp_access
;
473 gdb_assert_not_reached ("unhandled raw type");
477 /* Initialize the hardware breakpoint structure P for a breakpoint or
478 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
479 Returns -1 if TYPE is unsupported, or -2 if the particular combination
480 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
481 represents a breakpoint and 1 if type represents a watchpoint. */
483 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
484 int len
, struct arm_linux_hw_breakpoint
*p
)
486 arm_hwbp_type hwbp_type
;
489 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
491 if (hwbp_type
== arm_hwbp_break
)
493 /* For breakpoints, the length field encodes the mode. */
496 case 2: /* 16-bit Thumb mode breakpoint */
497 case 3: /* 32-bit Thumb mode breakpoint */
501 case 4: /* 32-bit ARM mode breakpoint */
512 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
513 CORE_ADDR aligned_addr
;
515 /* Can not set watchpoints for zero or negative lengths. */
518 /* The current ptrace interface can only handle watchpoints that are a
520 if ((len
& (len
- 1)) != 0)
523 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
524 range covered by a watchpoint. */
525 aligned_addr
= addr
& ~(max_wp_length
- 1);
526 if (aligned_addr
+ max_wp_length
< addr
+ len
)
529 mask
= (1 << len
) - 1;
532 p
->address
= (unsigned int) addr
;
533 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
535 return hwbp_type
!= arm_hwbp_break
;
538 /* Callback to mark a watch-/breakpoint to be updated in all threads of
539 the current process. */
542 update_registers_callback (thread_info
*thread
, int watch
, int i
)
544 struct lwp_info
*lwp
= get_thread_lwp (thread
);
546 /* The actual update is done later just before resuming the lwp,
547 we just mark that the registers need updating. */
549 lwp
->arch_private
->wpts_changed
[i
] = 1;
551 lwp
->arch_private
->bpts_changed
[i
] = 1;
553 /* If the lwp isn't stopped, force it to momentarily pause, so
554 we can update its breakpoint registers. */
556 linux_stop_lwp (lwp
);
560 arm_supports_z_point_type (char z_type
)
566 case Z_PACKET_WRITE_WP
:
567 case Z_PACKET_READ_WP
:
568 case Z_PACKET_ACCESS_WP
:
571 /* Leave the handling of sw breakpoints with the gdb client. */
576 /* Insert hardware break-/watchpoint. */
578 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
579 int len
, struct raw_breakpoint
*bp
)
581 struct process_info
*proc
= current_process ();
582 struct arm_linux_hw_breakpoint p
, *pts
;
585 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
589 return watch
== -1 ? 1 : -1;
594 count
= arm_linux_get_hw_watchpoint_count ();
595 pts
= proc
->priv
->arch_private
->wpts
;
599 count
= arm_linux_get_hw_breakpoint_count ();
600 pts
= proc
->priv
->arch_private
->bpts
;
603 for (i
= 0; i
< count
; i
++)
604 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
608 /* Only update the threads of the current process. */
609 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
611 update_registers_callback (thread
, watch
, i
);
617 /* We're out of watchpoints. */
621 /* Remove hardware break-/watchpoint. */
623 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
624 int len
, struct raw_breakpoint
*bp
)
626 struct process_info
*proc
= current_process ();
627 struct arm_linux_hw_breakpoint p
, *pts
;
630 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
639 count
= arm_linux_get_hw_watchpoint_count ();
640 pts
= proc
->priv
->arch_private
->wpts
;
644 count
= arm_linux_get_hw_breakpoint_count ();
645 pts
= proc
->priv
->arch_private
->bpts
;
648 for (i
= 0; i
< count
; i
++)
649 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
651 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
653 /* Only update the threads of the current process. */
654 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
656 update_registers_callback (thread
, watch
, i
);
662 /* No watchpoint matched. */
666 /* Return whether current thread is stopped due to a watchpoint. */
668 arm_stopped_by_watchpoint (void)
670 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
673 /* We must be able to set hardware watchpoints. */
674 if (arm_linux_get_hw_watchpoint_count () == 0)
677 /* Retrieve siginfo. */
679 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
683 /* This must be a hardware breakpoint. */
684 if (siginfo
.si_signo
!= SIGTRAP
685 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
688 /* If we are in a positive slot then we're looking at a breakpoint and not
690 if (siginfo
.si_errno
>= 0)
693 /* Cache stopped data address for use by arm_stopped_data_address. */
694 lwp
->arch_private
->stopped_data_address
695 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
700 /* Return data address that triggered watchpoint. Called only if
701 arm_stopped_by_watchpoint returned true. */
703 arm_stopped_data_address (void)
705 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
706 return lwp
->arch_private
->stopped_data_address
;
709 /* Called when a new process is created. */
710 static struct arch_process_info
*
711 arm_new_process (void)
713 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
717 /* Called when a process is being deleted. */
720 arm_delete_process (struct arch_process_info
*info
)
725 /* Called when a new thread is detected. */
727 arm_new_thread (struct lwp_info
*lwp
)
729 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
732 for (i
= 0; i
< MAX_BPTS
; i
++)
733 info
->bpts_changed
[i
] = 1;
734 for (i
= 0; i
< MAX_WPTS
; i
++)
735 info
->wpts_changed
[i
] = 1;
737 lwp
->arch_private
= info
;
740 /* Function to call when a thread is being deleted. */
743 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
749 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
751 struct arch_process_info
*parent_proc_info
;
752 struct arch_process_info
*child_proc_info
;
753 struct lwp_info
*child_lwp
;
754 struct arch_lwp_info
*child_lwp_info
;
757 /* These are allocated by linux_add_process. */
758 gdb_assert (parent
->priv
!= NULL
759 && parent
->priv
->arch_private
!= NULL
);
760 gdb_assert (child
->priv
!= NULL
761 && child
->priv
->arch_private
!= NULL
);
763 parent_proc_info
= parent
->priv
->arch_private
;
764 child_proc_info
= child
->priv
->arch_private
;
766 /* Linux kernel before 2.6.33 commit
767 72f674d203cd230426437cdcf7dd6f681dad8b0d
768 will inherit hardware debug registers from parent
769 on fork/vfork/clone. Newer Linux kernels create such tasks with
770 zeroed debug registers.
772 GDB core assumes the child inherits the watchpoints/hw
773 breakpoints of the parent, and will remove them all from the
774 forked off process. Copy the debug registers mirrors into the
775 new process so that all breakpoints and watchpoints can be
776 removed together. The debug registers mirror will become zeroed
777 in the end before detaching the forked off process, thus making
778 this compatible with older Linux kernels too. */
780 *child_proc_info
= *parent_proc_info
;
782 /* Mark all the hardware breakpoints and watchpoints as changed to
783 make sure that the registers will be updated. */
784 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
785 child_lwp_info
= child_lwp
->arch_private
;
786 for (i
= 0; i
< MAX_BPTS
; i
++)
787 child_lwp_info
->bpts_changed
[i
] = 1;
788 for (i
= 0; i
< MAX_WPTS
; i
++)
789 child_lwp_info
->wpts_changed
[i
] = 1;
792 /* Called when resuming a thread.
793 If the debug regs have changed, update the thread's copies. */
795 arm_prepare_to_resume (struct lwp_info
*lwp
)
797 struct thread_info
*thread
= get_lwp_thread (lwp
);
798 int pid
= lwpid_of (thread
);
799 struct process_info
*proc
= find_process_pid (pid_of (thread
));
800 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
801 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
804 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
805 if (lwp_info
->bpts_changed
[i
])
809 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
810 if (ptrace (PTRACE_SETHBPREGS
, pid
,
811 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
812 &proc_info
->bpts
[i
].address
) < 0)
813 perror_with_name ("Unexpected error setting breakpoint address");
815 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
816 if (ptrace (PTRACE_SETHBPREGS
, pid
,
817 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
818 &proc_info
->bpts
[i
].control
) < 0)
819 perror_with_name ("Unexpected error setting breakpoint");
821 lwp_info
->bpts_changed
[i
] = 0;
824 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
825 if (lwp_info
->wpts_changed
[i
])
829 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
830 if (ptrace (PTRACE_SETHBPREGS
, pid
,
831 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
832 &proc_info
->wpts
[i
].address
) < 0)
833 perror_with_name ("Unexpected error setting watchpoint address");
835 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
836 if (ptrace (PTRACE_SETHBPREGS
, pid
,
837 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
838 &proc_info
->wpts
[i
].control
) < 0)
839 perror_with_name ("Unexpected error setting watchpoint");
841 lwp_info
->wpts_changed
[i
] = 0;
845 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
846 addition, set IS_THUMB depending on whether we will return to ARM
848 See arm-linux.h for stack layout details. */
850 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
854 unsigned long sp_data
;
855 /* Offset of PC register. */
857 CORE_ADDR next_pc
= 0;
860 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
862 collect_register_by_name (regcache
, "sp", &sp
);
863 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
865 pc_offset
= arm_linux_sigreturn_next_pc_offset
866 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
868 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
870 /* Set IS_THUMB according the CPSR saved on the stack. */
871 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
872 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
877 /* When PC is at a syscall instruction, return the PC of the next
878 instruction to be executed. */
880 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
882 CORE_ADDR next_pc
= 0;
883 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
884 int is_thumb
= arm_is_thumb_mode ();
885 ULONGEST svc_number
= 0;
886 struct regcache
*regcache
= self
->regcache
;
890 collect_register (regcache
, 7, &svc_number
);
895 unsigned long this_instr
;
896 unsigned long svc_operand
;
898 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
899 svc_operand
= (0x00ffffff & this_instr
);
901 if (svc_operand
) /* OABI. */
903 svc_number
= svc_operand
- 0x900000;
907 collect_register (regcache
, 7, &svc_number
);
913 /* This is a sigreturn or sigreturn_rt syscall. */
914 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
916 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
918 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
921 /* Addresses for calling Thumb functions have the bit 0 set. */
923 next_pc
= MAKE_THUMB_ADDR (next_pc
);
928 static const struct target_desc
*
929 arm_read_description (void)
931 unsigned long arm_hwcap
= linux_get_hwcap (4);
933 if (arm_hwcap
& HWCAP_IWMMXT
)
934 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
936 if (arm_hwcap
& HWCAP_VFP
)
938 /* Make sure that the kernel supports reading VFP registers. Support was
940 int pid
= lwpid_of (current_thread
);
942 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
943 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
944 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
946 /* NEON implies either no VFP, or VFPv3-D32. We only support
948 if (arm_hwcap
& HWCAP_NEON
)
949 return aarch32_linux_read_description ();
950 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
951 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
953 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
956 /* The default configuration uses legacy FPA registers, probably
958 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
962 arm_target::low_arch_setup ()
964 int tid
= lwpid_of (current_thread
);
968 /* Query hardware watchpoint/breakpoint capabilities. */
969 arm_linux_init_hwbp_cap (tid
);
971 current_process ()->tdesc
= arm_read_description ();
973 iov
.iov_base
= gpregs
;
974 iov
.iov_len
= sizeof (gpregs
);
976 /* Check if PTRACE_GETREGSET works. */
977 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
978 have_ptrace_getregset
= 1;
980 have_ptrace_getregset
= 0;
984 arm_target::supports_software_single_step ()
989 /* Fetch the next possible PCs after the current instruction executes. */
991 std::vector
<CORE_ADDR
>
992 arm_target::low_get_next_pcs (regcache
*regcache
)
994 struct arm_get_next_pcs next_pcs_ctx
;
996 arm_get_next_pcs_ctor (&next_pcs_ctx
,
998 /* Byte order is ignored assumed as host. */
1004 return arm_get_next_pcs (&next_pcs_ctx
);
1007 /* Support for hardware single step. */
1010 arm_supports_hardware_single_step (void)
1015 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1018 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1020 if (arm_is_thumb_mode ())
1021 collect_register_by_name (regcache
, "r7", sysno
);
1027 collect_register_by_name (regcache
, "pc", &pc
);
1029 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1030 *sysno
= UNKNOWN_SYSCALL
;
1033 unsigned long svc_operand
= (0x00ffffff & insn
);
1038 *sysno
= svc_operand
- 0x900000;
1043 collect_register_by_name (regcache
, "r7", sysno
);
1049 /* Register sets without using PTRACE_GETREGSET. */
1051 static struct regset_info arm_regsets
[] = {
1052 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1053 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1054 arm_fill_gregset
, arm_store_gregset
},
1055 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1056 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1057 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1058 arm_fill_vfpregset
, arm_store_vfpregset
},
1062 static struct regsets_info arm_regsets_info
=
1064 arm_regsets
, /* regsets */
1065 0, /* num_regsets */
1066 NULL
, /* disabled_regsets */
1069 static struct usrregs_info arm_usrregs_info
=
1075 static struct regs_info regs_info_arm
=
1077 NULL
, /* regset_bitmap */
1083 arm_target::get_regs_info ()
1085 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1087 if (have_ptrace_getregset
== 1
1088 && (is_aarch32_linux_description (tdesc
)
1089 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1090 return ®s_info_aarch32
;
1092 return ®s_info_arm
;
1095 struct linux_target_ops the_low_target
= {
1096 arm_supports_z_point_type
,
1099 arm_stopped_by_watchpoint
,
1100 arm_stopped_data_address
,
1101 NULL
, /* collect_ptrace_register */
1102 NULL
, /* supply_ptrace_register */
1103 NULL
, /* siginfo_fixup */
1109 arm_prepare_to_resume
,
1110 NULL
, /* process_qsupported */
1111 NULL
, /* supports_tracepoints */
1112 NULL
, /* get_thread_area */
1113 NULL
, /* install_fast_tracepoint_jump_pad */
1114 NULL
, /* emit_ops */
1115 NULL
, /* get_min_fast_tracepoint_insn_len */
1116 NULL
, /* supports_range_stepping */
1117 arm_supports_hardware_single_step
,
1118 arm_get_syscall_trapinfo
,
1121 /* The linux target ops object. */
1123 linux_process_target
*the_linux_target
= &the_arm_target
;
1126 initialize_low_arch (void)
1128 initialize_low_arch_aarch32 ();
1129 initialize_regsets_info (&arm_regsets_info
);