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
;
73 bool supports_z_point_type (char z_type
) override
;
77 void low_arch_setup () override
;
79 bool low_cannot_fetch_register (int regno
) override
;
81 bool low_cannot_store_register (int regno
) override
;
83 bool low_supports_breakpoints () override
;
85 CORE_ADDR
low_get_pc (regcache
*regcache
) override
;
87 void low_set_pc (regcache
*regcache
, CORE_ADDR newpc
) override
;
89 std::vector
<CORE_ADDR
> low_get_next_pcs (regcache
*regcache
) override
;
91 bool low_breakpoint_at (CORE_ADDR pc
) override
;
93 int low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
94 int size
, raw_breakpoint
*bp
) override
;
96 int low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
97 int size
, raw_breakpoint
*bp
) override
;
100 /* The singleton target ops object. */
102 static arm_target the_arm_target
;
105 arm_target::low_supports_breakpoints ()
111 arm_target::low_get_pc (regcache
*regcache
)
113 return linux_get_pc_32bit (regcache
);
117 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
119 linux_set_pc_32bit (regcache
, pc
);
123 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
125 return arm_breakpoint_kind_from_pc (pcptr
);
129 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
131 return arm_breakpoint_kind_from_current_state (pcptr
);
135 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
137 return arm_sw_breakpoint_from_kind (kind
, size
);
141 arm_target::low_breakpoint_at (CORE_ADDR pc
)
143 return arm_breakpoint_at (pc
);
146 /* Information describing the hardware breakpoint capabilities. */
150 unsigned char max_wp_length
;
151 unsigned char wp_count
;
152 unsigned char bp_count
;
153 } arm_linux_hwbp_cap
;
155 /* Enum describing the different types of ARM hardware break-/watch-points. */
164 /* Type describing an ARM Hardware Breakpoint Control register value. */
165 typedef unsigned int arm_hwbp_control_t
;
167 /* Structure used to keep track of hardware break-/watch-points. */
168 struct arm_linux_hw_breakpoint
170 /* Address to break on, or being watched. */
171 unsigned int address
;
172 /* Control register for break-/watch- point. */
173 arm_hwbp_control_t control
;
176 /* Since we cannot dynamically allocate subfields of arch_process_info,
177 assume a maximum number of supported break-/watchpoints. */
181 /* Per-process arch-specific data we want to keep. */
182 struct arch_process_info
184 /* Hardware breakpoints for this process. */
185 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
186 /* Hardware watchpoints for this process. */
187 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
190 /* Per-thread arch-specific data we want to keep. */
193 /* Non-zero if our copy differs from what's recorded in the thread. */
194 char bpts_changed
[MAX_BPTS
];
195 char wpts_changed
[MAX_WPTS
];
196 /* Cached stopped data address. */
197 CORE_ADDR stopped_data_address
;
200 /* These are in <asm/elf.h> in current kernels. */
202 #define HWCAP_IWMMXT 512
203 #define HWCAP_NEON 4096
204 #define HWCAP_VFPv3 8192
205 #define HWCAP_VFPv3D16 16384
207 #ifdef HAVE_SYS_REG_H
211 #define arm_num_regs 26
213 static int arm_regmap
[] = {
214 0, 4, 8, 12, 16, 20, 24, 28,
215 32, 36, 40, 44, 48, 52, 56, 60,
216 -1, -1, -1, -1, -1, -1, -1, -1, -1,
220 /* Forward declarations needed for get_next_pcs ops. */
221 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
225 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
228 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
230 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
232 /* get_next_pcs operations. */
233 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
234 get_next_pcs_read_memory_unsigned_integer
,
235 get_next_pcs_syscall_next_pc
,
236 get_next_pcs_addr_bits_remove
,
237 get_next_pcs_is_thumb
,
238 arm_linux_get_next_pcs_fixup
,
242 arm_target::low_cannot_store_register (int regno
)
244 return (regno
>= arm_num_regs
);
248 arm_target::low_cannot_fetch_register (int regno
)
250 return (regno
>= arm_num_regs
);
254 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
256 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
259 for (int i
= 0; i
< 16; i
++)
260 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
262 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
263 for (int i
= 0; i
< 6; i
++)
264 collect_register (regcache
, arm_num_regs
+ i
+ 16,
265 (char *) buf
+ 16 * 8 + i
* 4);
269 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
271 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
274 for (int i
= 0; i
< 16; i
++)
275 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
277 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
278 for (int i
= 0; i
< 6; i
++)
279 supply_register (regcache
, arm_num_regs
+ i
+ 16,
280 (char *) buf
+ 16 * 8 + i
* 4);
284 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
288 if (is_aarch32_linux_description (regcache
->tdesc
))
292 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
294 if (fp_type
== ARM_FP_TYPE_VFPV3
)
296 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
302 arm_fill_vfpregset_num (regcache
, buf
, num
);
305 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
307 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
309 return UNMAKE_THUMB_ADDR (val
);
313 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
317 if (is_aarch32_linux_description (regcache
->tdesc
))
321 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
323 if (fp_type
== ARM_FP_TYPE_VFPV3
)
325 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
331 arm_store_vfpregset_num (regcache
, buf
, num
);
334 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
336 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
338 return arm_is_thumb_mode ();
341 /* Read memory from the inferior.
342 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
343 read_memory_unsigned_integer. */
345 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
352 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
357 /* Fetch the thread-local storage pointer for libthread_db. */
360 ps_get_thread_area (struct ps_prochandle
*ph
,
361 lwpid_t lwpid
, int idx
, void **base
)
363 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
366 /* IDX is the bias from the thread pointer to the beginning of the
367 thread descriptor. It has to be subtracted due to implementation
368 quirks in libthread_db. */
369 *base
= (void *) ((char *)*base
- idx
);
375 /* Query Hardware Breakpoint information for the target we are attached to
376 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
378 arm_linux_init_hwbp_cap (int pid
)
382 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
385 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
386 if (arm_linux_hwbp_cap
.arch
== 0)
389 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
390 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
391 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
393 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
394 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
395 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
396 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
399 /* How many hardware breakpoints are available? */
401 arm_linux_get_hw_breakpoint_count (void)
403 return arm_linux_hwbp_cap
.bp_count
;
406 /* How many hardware watchpoints are available? */
408 arm_linux_get_hw_watchpoint_count (void)
410 return arm_linux_hwbp_cap
.wp_count
;
413 /* Maximum length of area watched by hardware watchpoint. */
415 arm_linux_get_hw_watchpoint_max_length (void)
417 return arm_linux_hwbp_cap
.max_wp_length
;
420 /* Initialize an ARM hardware break-/watch-point control register value.
421 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
422 type of break-/watch-point; ENABLE indicates whether the point is enabled.
424 static arm_hwbp_control_t
425 arm_hwbp_control_initialize (unsigned byte_address_select
,
426 arm_hwbp_type hwbp_type
,
429 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
430 gdb_assert (hwbp_type
!= arm_hwbp_break
431 || ((byte_address_select
& 0xfU
) != 0));
433 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
436 /* Does the breakpoint control value CONTROL have the enable bit set? */
438 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
440 return control
& 0x1;
443 /* Is the breakpoint control value CONTROL initialized? */
445 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
450 /* Change a breakpoint control word so that it is in the disabled state. */
451 static arm_hwbp_control_t
452 arm_hwbp_control_disable (arm_hwbp_control_t control
)
454 return control
& ~0x1;
457 /* Are two break-/watch-points equal? */
459 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
460 const struct arm_linux_hw_breakpoint
*p2
)
462 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
465 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
468 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
472 case raw_bkpt_type_hw
:
473 return arm_hwbp_break
;
474 case raw_bkpt_type_write_wp
:
475 return arm_hwbp_store
;
476 case raw_bkpt_type_read_wp
:
477 return arm_hwbp_load
;
478 case raw_bkpt_type_access_wp
:
479 return arm_hwbp_access
;
481 gdb_assert_not_reached ("unhandled raw type");
485 /* Initialize the hardware breakpoint structure P for a breakpoint or
486 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
487 Returns -1 if TYPE is unsupported, or -2 if the particular combination
488 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
489 represents a breakpoint and 1 if type represents a watchpoint. */
491 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
492 int len
, struct arm_linux_hw_breakpoint
*p
)
494 arm_hwbp_type hwbp_type
;
497 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
499 if (hwbp_type
== arm_hwbp_break
)
501 /* For breakpoints, the length field encodes the mode. */
504 case 2: /* 16-bit Thumb mode breakpoint */
505 case 3: /* 32-bit Thumb mode breakpoint */
509 case 4: /* 32-bit ARM mode breakpoint */
520 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
521 CORE_ADDR aligned_addr
;
523 /* Can not set watchpoints for zero or negative lengths. */
526 /* The current ptrace interface can only handle watchpoints that are a
528 if ((len
& (len
- 1)) != 0)
531 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
532 range covered by a watchpoint. */
533 aligned_addr
= addr
& ~(max_wp_length
- 1);
534 if (aligned_addr
+ max_wp_length
< addr
+ len
)
537 mask
= (1 << len
) - 1;
540 p
->address
= (unsigned int) addr
;
541 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
543 return hwbp_type
!= arm_hwbp_break
;
546 /* Callback to mark a watch-/breakpoint to be updated in all threads of
547 the current process. */
550 update_registers_callback (thread_info
*thread
, int watch
, int i
)
552 struct lwp_info
*lwp
= get_thread_lwp (thread
);
554 /* The actual update is done later just before resuming the lwp,
555 we just mark that the registers need updating. */
557 lwp
->arch_private
->wpts_changed
[i
] = 1;
559 lwp
->arch_private
->bpts_changed
[i
] = 1;
561 /* If the lwp isn't stopped, force it to momentarily pause, so
562 we can update its breakpoint registers. */
564 linux_stop_lwp (lwp
);
568 arm_target::supports_z_point_type (char z_type
)
574 case Z_PACKET_WRITE_WP
:
575 case Z_PACKET_READ_WP
:
576 case Z_PACKET_ACCESS_WP
:
579 /* Leave the handling of sw breakpoints with the gdb client. */
584 /* Insert hardware break-/watchpoint. */
586 arm_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
587 int len
, raw_breakpoint
*bp
)
589 struct process_info
*proc
= current_process ();
590 struct arm_linux_hw_breakpoint p
, *pts
;
593 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
597 return watch
== -1 ? 1 : -1;
602 count
= arm_linux_get_hw_watchpoint_count ();
603 pts
= proc
->priv
->arch_private
->wpts
;
607 count
= arm_linux_get_hw_breakpoint_count ();
608 pts
= proc
->priv
->arch_private
->bpts
;
611 for (i
= 0; i
< count
; i
++)
612 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
616 /* Only update the threads of the current process. */
617 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
619 update_registers_callback (thread
, watch
, i
);
625 /* We're out of watchpoints. */
629 /* Remove hardware break-/watchpoint. */
631 arm_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
632 int len
, raw_breakpoint
*bp
)
634 struct process_info
*proc
= current_process ();
635 struct arm_linux_hw_breakpoint p
, *pts
;
638 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
647 count
= arm_linux_get_hw_watchpoint_count ();
648 pts
= proc
->priv
->arch_private
->wpts
;
652 count
= arm_linux_get_hw_breakpoint_count ();
653 pts
= proc
->priv
->arch_private
->bpts
;
656 for (i
= 0; i
< count
; i
++)
657 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
659 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
661 /* Only update the threads of the current process. */
662 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
664 update_registers_callback (thread
, watch
, i
);
670 /* No watchpoint matched. */
674 /* Return whether current thread is stopped due to a watchpoint. */
676 arm_stopped_by_watchpoint (void)
678 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
681 /* We must be able to set hardware watchpoints. */
682 if (arm_linux_get_hw_watchpoint_count () == 0)
685 /* Retrieve siginfo. */
687 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
691 /* This must be a hardware breakpoint. */
692 if (siginfo
.si_signo
!= SIGTRAP
693 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
696 /* If we are in a positive slot then we're looking at a breakpoint and not
698 if (siginfo
.si_errno
>= 0)
701 /* Cache stopped data address for use by arm_stopped_data_address. */
702 lwp
->arch_private
->stopped_data_address
703 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
708 /* Return data address that triggered watchpoint. Called only if
709 arm_stopped_by_watchpoint returned true. */
711 arm_stopped_data_address (void)
713 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
714 return lwp
->arch_private
->stopped_data_address
;
717 /* Called when a new process is created. */
718 static struct arch_process_info
*
719 arm_new_process (void)
721 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
725 /* Called when a process is being deleted. */
728 arm_delete_process (struct arch_process_info
*info
)
733 /* Called when a new thread is detected. */
735 arm_new_thread (struct lwp_info
*lwp
)
737 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
740 for (i
= 0; i
< MAX_BPTS
; i
++)
741 info
->bpts_changed
[i
] = 1;
742 for (i
= 0; i
< MAX_WPTS
; i
++)
743 info
->wpts_changed
[i
] = 1;
745 lwp
->arch_private
= info
;
748 /* Function to call when a thread is being deleted. */
751 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
757 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
759 struct arch_process_info
*parent_proc_info
;
760 struct arch_process_info
*child_proc_info
;
761 struct lwp_info
*child_lwp
;
762 struct arch_lwp_info
*child_lwp_info
;
765 /* These are allocated by linux_add_process. */
766 gdb_assert (parent
->priv
!= NULL
767 && parent
->priv
->arch_private
!= NULL
);
768 gdb_assert (child
->priv
!= NULL
769 && child
->priv
->arch_private
!= NULL
);
771 parent_proc_info
= parent
->priv
->arch_private
;
772 child_proc_info
= child
->priv
->arch_private
;
774 /* Linux kernel before 2.6.33 commit
775 72f674d203cd230426437cdcf7dd6f681dad8b0d
776 will inherit hardware debug registers from parent
777 on fork/vfork/clone. Newer Linux kernels create such tasks with
778 zeroed debug registers.
780 GDB core assumes the child inherits the watchpoints/hw
781 breakpoints of the parent, and will remove them all from the
782 forked off process. Copy the debug registers mirrors into the
783 new process so that all breakpoints and watchpoints can be
784 removed together. The debug registers mirror will become zeroed
785 in the end before detaching the forked off process, thus making
786 this compatible with older Linux kernels too. */
788 *child_proc_info
= *parent_proc_info
;
790 /* Mark all the hardware breakpoints and watchpoints as changed to
791 make sure that the registers will be updated. */
792 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
793 child_lwp_info
= child_lwp
->arch_private
;
794 for (i
= 0; i
< MAX_BPTS
; i
++)
795 child_lwp_info
->bpts_changed
[i
] = 1;
796 for (i
= 0; i
< MAX_WPTS
; i
++)
797 child_lwp_info
->wpts_changed
[i
] = 1;
800 /* Called when resuming a thread.
801 If the debug regs have changed, update the thread's copies. */
803 arm_prepare_to_resume (struct lwp_info
*lwp
)
805 struct thread_info
*thread
= get_lwp_thread (lwp
);
806 int pid
= lwpid_of (thread
);
807 struct process_info
*proc
= find_process_pid (pid_of (thread
));
808 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
809 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
812 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
813 if (lwp_info
->bpts_changed
[i
])
817 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
818 if (ptrace (PTRACE_SETHBPREGS
, pid
,
819 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
820 &proc_info
->bpts
[i
].address
) < 0)
821 perror_with_name ("Unexpected error setting breakpoint address");
823 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
824 if (ptrace (PTRACE_SETHBPREGS
, pid
,
825 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
826 &proc_info
->bpts
[i
].control
) < 0)
827 perror_with_name ("Unexpected error setting breakpoint");
829 lwp_info
->bpts_changed
[i
] = 0;
832 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
833 if (lwp_info
->wpts_changed
[i
])
837 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
838 if (ptrace (PTRACE_SETHBPREGS
, pid
,
839 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
840 &proc_info
->wpts
[i
].address
) < 0)
841 perror_with_name ("Unexpected error setting watchpoint address");
843 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
844 if (ptrace (PTRACE_SETHBPREGS
, pid
,
845 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
846 &proc_info
->wpts
[i
].control
) < 0)
847 perror_with_name ("Unexpected error setting watchpoint");
849 lwp_info
->wpts_changed
[i
] = 0;
853 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
854 addition, set IS_THUMB depending on whether we will return to ARM
856 See arm-linux.h for stack layout details. */
858 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
862 unsigned long sp_data
;
863 /* Offset of PC register. */
865 CORE_ADDR next_pc
= 0;
868 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
870 collect_register_by_name (regcache
, "sp", &sp
);
871 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
873 pc_offset
= arm_linux_sigreturn_next_pc_offset
874 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
876 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
878 /* Set IS_THUMB according the CPSR saved on the stack. */
879 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
880 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
885 /* When PC is at a syscall instruction, return the PC of the next
886 instruction to be executed. */
888 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
890 CORE_ADDR next_pc
= 0;
891 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
892 int is_thumb
= arm_is_thumb_mode ();
893 ULONGEST svc_number
= 0;
894 struct regcache
*regcache
= self
->regcache
;
898 collect_register (regcache
, 7, &svc_number
);
903 unsigned long this_instr
;
904 unsigned long svc_operand
;
906 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
907 svc_operand
= (0x00ffffff & this_instr
);
909 if (svc_operand
) /* OABI. */
911 svc_number
= svc_operand
- 0x900000;
915 collect_register (regcache
, 7, &svc_number
);
921 /* This is a sigreturn or sigreturn_rt syscall. */
922 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
924 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
926 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
929 /* Addresses for calling Thumb functions have the bit 0 set. */
931 next_pc
= MAKE_THUMB_ADDR (next_pc
);
936 static const struct target_desc
*
937 arm_read_description (void)
939 unsigned long arm_hwcap
= linux_get_hwcap (4);
941 if (arm_hwcap
& HWCAP_IWMMXT
)
942 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
944 if (arm_hwcap
& HWCAP_VFP
)
946 /* Make sure that the kernel supports reading VFP registers. Support was
948 int pid
= lwpid_of (current_thread
);
950 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
951 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
952 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
954 /* NEON implies either no VFP, or VFPv3-D32. We only support
956 if (arm_hwcap
& HWCAP_NEON
)
957 return aarch32_linux_read_description ();
958 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
959 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
961 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
964 /* The default configuration uses legacy FPA registers, probably
966 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
970 arm_target::low_arch_setup ()
972 int tid
= lwpid_of (current_thread
);
976 /* Query hardware watchpoint/breakpoint capabilities. */
977 arm_linux_init_hwbp_cap (tid
);
979 current_process ()->tdesc
= arm_read_description ();
981 iov
.iov_base
= gpregs
;
982 iov
.iov_len
= sizeof (gpregs
);
984 /* Check if PTRACE_GETREGSET works. */
985 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
986 have_ptrace_getregset
= 1;
988 have_ptrace_getregset
= 0;
992 arm_target::supports_software_single_step ()
997 /* Fetch the next possible PCs after the current instruction executes. */
999 std::vector
<CORE_ADDR
>
1000 arm_target::low_get_next_pcs (regcache
*regcache
)
1002 struct arm_get_next_pcs next_pcs_ctx
;
1004 arm_get_next_pcs_ctor (&next_pcs_ctx
,
1006 /* Byte order is ignored assumed as host. */
1012 return arm_get_next_pcs (&next_pcs_ctx
);
1015 /* Support for hardware single step. */
1018 arm_supports_hardware_single_step (void)
1023 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1026 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1028 if (arm_is_thumb_mode ())
1029 collect_register_by_name (regcache
, "r7", sysno
);
1035 collect_register_by_name (regcache
, "pc", &pc
);
1037 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1038 *sysno
= UNKNOWN_SYSCALL
;
1041 unsigned long svc_operand
= (0x00ffffff & insn
);
1046 *sysno
= svc_operand
- 0x900000;
1051 collect_register_by_name (regcache
, "r7", sysno
);
1057 /* Register sets without using PTRACE_GETREGSET. */
1059 static struct regset_info arm_regsets
[] = {
1060 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1061 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1062 arm_fill_gregset
, arm_store_gregset
},
1063 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1064 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1065 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1066 arm_fill_vfpregset
, arm_store_vfpregset
},
1070 static struct regsets_info arm_regsets_info
=
1072 arm_regsets
, /* regsets */
1073 0, /* num_regsets */
1074 NULL
, /* disabled_regsets */
1077 static struct usrregs_info arm_usrregs_info
=
1083 static struct regs_info regs_info_arm
=
1085 NULL
, /* regset_bitmap */
1091 arm_target::get_regs_info ()
1093 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1095 if (have_ptrace_getregset
== 1
1096 && (is_aarch32_linux_description (tdesc
)
1097 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1098 return ®s_info_aarch32
;
1100 return ®s_info_arm
;
1103 struct linux_target_ops the_low_target
= {
1104 arm_stopped_by_watchpoint
,
1105 arm_stopped_data_address
,
1106 NULL
, /* collect_ptrace_register */
1107 NULL
, /* supply_ptrace_register */
1108 NULL
, /* siginfo_fixup */
1114 arm_prepare_to_resume
,
1115 NULL
, /* process_qsupported */
1116 NULL
, /* supports_tracepoints */
1117 NULL
, /* get_thread_area */
1118 NULL
, /* install_fast_tracepoint_jump_pad */
1119 NULL
, /* emit_ops */
1120 NULL
, /* get_min_fast_tracepoint_insn_len */
1121 NULL
, /* supports_range_stepping */
1122 arm_supports_hardware_single_step
,
1123 arm_get_syscall_trapinfo
,
1126 /* The linux target ops object. */
1128 linux_process_target
*the_linux_target
= &the_arm_target
;
1131 initialize_low_arch (void)
1133 initialize_low_arch_aarch32 ();
1134 initialize_regsets_info (&arm_regsets_info
);