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
;
94 /* The singleton target ops object. */
96 static arm_target the_arm_target
;
99 arm_target::low_supports_breakpoints ()
105 arm_target::low_get_pc (regcache
*regcache
)
107 return linux_get_pc_32bit (regcache
);
111 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
113 linux_set_pc_32bit (regcache
, pc
);
117 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
119 return arm_breakpoint_kind_from_pc (pcptr
);
123 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
125 return arm_breakpoint_kind_from_current_state (pcptr
);
129 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
131 return arm_sw_breakpoint_from_kind (kind
, size
);
135 arm_target::low_breakpoint_at (CORE_ADDR pc
)
137 return arm_breakpoint_at (pc
);
140 /* Information describing the hardware breakpoint capabilities. */
144 unsigned char max_wp_length
;
145 unsigned char wp_count
;
146 unsigned char bp_count
;
147 } arm_linux_hwbp_cap
;
149 /* Enum describing the different types of ARM hardware break-/watch-points. */
158 /* Type describing an ARM Hardware Breakpoint Control register value. */
159 typedef unsigned int arm_hwbp_control_t
;
161 /* Structure used to keep track of hardware break-/watch-points. */
162 struct arm_linux_hw_breakpoint
164 /* Address to break on, or being watched. */
165 unsigned int address
;
166 /* Control register for break-/watch- point. */
167 arm_hwbp_control_t control
;
170 /* Since we cannot dynamically allocate subfields of arch_process_info,
171 assume a maximum number of supported break-/watchpoints. */
175 /* Per-process arch-specific data we want to keep. */
176 struct arch_process_info
178 /* Hardware breakpoints for this process. */
179 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
180 /* Hardware watchpoints for this process. */
181 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
184 /* Per-thread arch-specific data we want to keep. */
187 /* Non-zero if our copy differs from what's recorded in the thread. */
188 char bpts_changed
[MAX_BPTS
];
189 char wpts_changed
[MAX_WPTS
];
190 /* Cached stopped data address. */
191 CORE_ADDR stopped_data_address
;
194 /* These are in <asm/elf.h> in current kernels. */
196 #define HWCAP_IWMMXT 512
197 #define HWCAP_NEON 4096
198 #define HWCAP_VFPv3 8192
199 #define HWCAP_VFPv3D16 16384
201 #ifdef HAVE_SYS_REG_H
205 #define arm_num_regs 26
207 static int arm_regmap
[] = {
208 0, 4, 8, 12, 16, 20, 24, 28,
209 32, 36, 40, 44, 48, 52, 56, 60,
210 -1, -1, -1, -1, -1, -1, -1, -1, -1,
214 /* Forward declarations needed for get_next_pcs ops. */
215 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
219 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
222 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
224 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
226 /* get_next_pcs operations. */
227 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
228 get_next_pcs_read_memory_unsigned_integer
,
229 get_next_pcs_syscall_next_pc
,
230 get_next_pcs_addr_bits_remove
,
231 get_next_pcs_is_thumb
,
232 arm_linux_get_next_pcs_fixup
,
236 arm_target::low_cannot_store_register (int regno
)
238 return (regno
>= arm_num_regs
);
242 arm_target::low_cannot_fetch_register (int regno
)
244 return (regno
>= arm_num_regs
);
248 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
250 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
253 for (int i
= 0; i
< 16; i
++)
254 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
256 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
257 for (int i
= 0; i
< 6; i
++)
258 collect_register (regcache
, arm_num_regs
+ i
+ 16,
259 (char *) buf
+ 16 * 8 + i
* 4);
263 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
265 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
268 for (int i
= 0; i
< 16; i
++)
269 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
271 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
272 for (int i
= 0; i
< 6; i
++)
273 supply_register (regcache
, arm_num_regs
+ i
+ 16,
274 (char *) buf
+ 16 * 8 + i
* 4);
278 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
282 if (is_aarch32_linux_description (regcache
->tdesc
))
286 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
288 if (fp_type
== ARM_FP_TYPE_VFPV3
)
290 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
296 arm_fill_vfpregset_num (regcache
, buf
, num
);
299 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
301 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
303 return UNMAKE_THUMB_ADDR (val
);
307 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
311 if (is_aarch32_linux_description (regcache
->tdesc
))
315 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
317 if (fp_type
== ARM_FP_TYPE_VFPV3
)
319 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
325 arm_store_vfpregset_num (regcache
, buf
, num
);
328 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
330 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
332 return arm_is_thumb_mode ();
335 /* Read memory from the inferior.
336 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
337 read_memory_unsigned_integer. */
339 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
346 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
351 /* Fetch the thread-local storage pointer for libthread_db. */
354 ps_get_thread_area (struct ps_prochandle
*ph
,
355 lwpid_t lwpid
, int idx
, void **base
)
357 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
360 /* IDX is the bias from the thread pointer to the beginning of the
361 thread descriptor. It has to be subtracted due to implementation
362 quirks in libthread_db. */
363 *base
= (void *) ((char *)*base
- idx
);
369 /* Query Hardware Breakpoint information for the target we are attached to
370 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
372 arm_linux_init_hwbp_cap (int pid
)
376 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
379 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
380 if (arm_linux_hwbp_cap
.arch
== 0)
383 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
384 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
385 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
387 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
388 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
389 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
390 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
393 /* How many hardware breakpoints are available? */
395 arm_linux_get_hw_breakpoint_count (void)
397 return arm_linux_hwbp_cap
.bp_count
;
400 /* How many hardware watchpoints are available? */
402 arm_linux_get_hw_watchpoint_count (void)
404 return arm_linux_hwbp_cap
.wp_count
;
407 /* Maximum length of area watched by hardware watchpoint. */
409 arm_linux_get_hw_watchpoint_max_length (void)
411 return arm_linux_hwbp_cap
.max_wp_length
;
414 /* Initialize an ARM hardware break-/watch-point control register value.
415 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
416 type of break-/watch-point; ENABLE indicates whether the point is enabled.
418 static arm_hwbp_control_t
419 arm_hwbp_control_initialize (unsigned byte_address_select
,
420 arm_hwbp_type hwbp_type
,
423 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
424 gdb_assert (hwbp_type
!= arm_hwbp_break
425 || ((byte_address_select
& 0xfU
) != 0));
427 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
430 /* Does the breakpoint control value CONTROL have the enable bit set? */
432 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
434 return control
& 0x1;
437 /* Is the breakpoint control value CONTROL initialized? */
439 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
444 /* Change a breakpoint control word so that it is in the disabled state. */
445 static arm_hwbp_control_t
446 arm_hwbp_control_disable (arm_hwbp_control_t control
)
448 return control
& ~0x1;
451 /* Are two break-/watch-points equal? */
453 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
454 const struct arm_linux_hw_breakpoint
*p2
)
456 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
459 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
462 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
466 case raw_bkpt_type_hw
:
467 return arm_hwbp_break
;
468 case raw_bkpt_type_write_wp
:
469 return arm_hwbp_store
;
470 case raw_bkpt_type_read_wp
:
471 return arm_hwbp_load
;
472 case raw_bkpt_type_access_wp
:
473 return arm_hwbp_access
;
475 gdb_assert_not_reached ("unhandled raw type");
479 /* Initialize the hardware breakpoint structure P for a breakpoint or
480 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
481 Returns -1 if TYPE is unsupported, or -2 if the particular combination
482 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
483 represents a breakpoint and 1 if type represents a watchpoint. */
485 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
486 int len
, struct arm_linux_hw_breakpoint
*p
)
488 arm_hwbp_type hwbp_type
;
491 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
493 if (hwbp_type
== arm_hwbp_break
)
495 /* For breakpoints, the length field encodes the mode. */
498 case 2: /* 16-bit Thumb mode breakpoint */
499 case 3: /* 32-bit Thumb mode breakpoint */
503 case 4: /* 32-bit ARM mode breakpoint */
514 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
515 CORE_ADDR aligned_addr
;
517 /* Can not set watchpoints for zero or negative lengths. */
520 /* The current ptrace interface can only handle watchpoints that are a
522 if ((len
& (len
- 1)) != 0)
525 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
526 range covered by a watchpoint. */
527 aligned_addr
= addr
& ~(max_wp_length
- 1);
528 if (aligned_addr
+ max_wp_length
< addr
+ len
)
531 mask
= (1 << len
) - 1;
534 p
->address
= (unsigned int) addr
;
535 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
537 return hwbp_type
!= arm_hwbp_break
;
540 /* Callback to mark a watch-/breakpoint to be updated in all threads of
541 the current process. */
544 update_registers_callback (thread_info
*thread
, int watch
, int i
)
546 struct lwp_info
*lwp
= get_thread_lwp (thread
);
548 /* The actual update is done later just before resuming the lwp,
549 we just mark that the registers need updating. */
551 lwp
->arch_private
->wpts_changed
[i
] = 1;
553 lwp
->arch_private
->bpts_changed
[i
] = 1;
555 /* If the lwp isn't stopped, force it to momentarily pause, so
556 we can update its breakpoint registers. */
558 linux_stop_lwp (lwp
);
562 arm_target::supports_z_point_type (char z_type
)
568 case Z_PACKET_WRITE_WP
:
569 case Z_PACKET_READ_WP
:
570 case Z_PACKET_ACCESS_WP
:
573 /* Leave the handling of sw breakpoints with the gdb client. */
578 /* Insert hardware break-/watchpoint. */
580 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
581 int len
, struct raw_breakpoint
*bp
)
583 struct process_info
*proc
= current_process ();
584 struct arm_linux_hw_breakpoint p
, *pts
;
587 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
591 return watch
== -1 ? 1 : -1;
596 count
= arm_linux_get_hw_watchpoint_count ();
597 pts
= proc
->priv
->arch_private
->wpts
;
601 count
= arm_linux_get_hw_breakpoint_count ();
602 pts
= proc
->priv
->arch_private
->bpts
;
605 for (i
= 0; i
< count
; i
++)
606 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
610 /* Only update the threads of the current process. */
611 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
613 update_registers_callback (thread
, watch
, i
);
619 /* We're out of watchpoints. */
623 /* Remove hardware break-/watchpoint. */
625 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
626 int len
, struct raw_breakpoint
*bp
)
628 struct process_info
*proc
= current_process ();
629 struct arm_linux_hw_breakpoint p
, *pts
;
632 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
641 count
= arm_linux_get_hw_watchpoint_count ();
642 pts
= proc
->priv
->arch_private
->wpts
;
646 count
= arm_linux_get_hw_breakpoint_count ();
647 pts
= proc
->priv
->arch_private
->bpts
;
650 for (i
= 0; i
< count
; i
++)
651 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
653 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
655 /* Only update the threads of the current process. */
656 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
658 update_registers_callback (thread
, watch
, i
);
664 /* No watchpoint matched. */
668 /* Return whether current thread is stopped due to a watchpoint. */
670 arm_stopped_by_watchpoint (void)
672 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
675 /* We must be able to set hardware watchpoints. */
676 if (arm_linux_get_hw_watchpoint_count () == 0)
679 /* Retrieve siginfo. */
681 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
685 /* This must be a hardware breakpoint. */
686 if (siginfo
.si_signo
!= SIGTRAP
687 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
690 /* If we are in a positive slot then we're looking at a breakpoint and not
692 if (siginfo
.si_errno
>= 0)
695 /* Cache stopped data address for use by arm_stopped_data_address. */
696 lwp
->arch_private
->stopped_data_address
697 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
702 /* Return data address that triggered watchpoint. Called only if
703 arm_stopped_by_watchpoint returned true. */
705 arm_stopped_data_address (void)
707 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
708 return lwp
->arch_private
->stopped_data_address
;
711 /* Called when a new process is created. */
712 static struct arch_process_info
*
713 arm_new_process (void)
715 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
719 /* Called when a process is being deleted. */
722 arm_delete_process (struct arch_process_info
*info
)
727 /* Called when a new thread is detected. */
729 arm_new_thread (struct lwp_info
*lwp
)
731 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
734 for (i
= 0; i
< MAX_BPTS
; i
++)
735 info
->bpts_changed
[i
] = 1;
736 for (i
= 0; i
< MAX_WPTS
; i
++)
737 info
->wpts_changed
[i
] = 1;
739 lwp
->arch_private
= info
;
742 /* Function to call when a thread is being deleted. */
745 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
751 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
753 struct arch_process_info
*parent_proc_info
;
754 struct arch_process_info
*child_proc_info
;
755 struct lwp_info
*child_lwp
;
756 struct arch_lwp_info
*child_lwp_info
;
759 /* These are allocated by linux_add_process. */
760 gdb_assert (parent
->priv
!= NULL
761 && parent
->priv
->arch_private
!= NULL
);
762 gdb_assert (child
->priv
!= NULL
763 && child
->priv
->arch_private
!= NULL
);
765 parent_proc_info
= parent
->priv
->arch_private
;
766 child_proc_info
= child
->priv
->arch_private
;
768 /* Linux kernel before 2.6.33 commit
769 72f674d203cd230426437cdcf7dd6f681dad8b0d
770 will inherit hardware debug registers from parent
771 on fork/vfork/clone. Newer Linux kernels create such tasks with
772 zeroed debug registers.
774 GDB core assumes the child inherits the watchpoints/hw
775 breakpoints of the parent, and will remove them all from the
776 forked off process. Copy the debug registers mirrors into the
777 new process so that all breakpoints and watchpoints can be
778 removed together. The debug registers mirror will become zeroed
779 in the end before detaching the forked off process, thus making
780 this compatible with older Linux kernels too. */
782 *child_proc_info
= *parent_proc_info
;
784 /* Mark all the hardware breakpoints and watchpoints as changed to
785 make sure that the registers will be updated. */
786 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
787 child_lwp_info
= child_lwp
->arch_private
;
788 for (i
= 0; i
< MAX_BPTS
; i
++)
789 child_lwp_info
->bpts_changed
[i
] = 1;
790 for (i
= 0; i
< MAX_WPTS
; i
++)
791 child_lwp_info
->wpts_changed
[i
] = 1;
794 /* Called when resuming a thread.
795 If the debug regs have changed, update the thread's copies. */
797 arm_prepare_to_resume (struct lwp_info
*lwp
)
799 struct thread_info
*thread
= get_lwp_thread (lwp
);
800 int pid
= lwpid_of (thread
);
801 struct process_info
*proc
= find_process_pid (pid_of (thread
));
802 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
803 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
806 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
807 if (lwp_info
->bpts_changed
[i
])
811 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
812 if (ptrace (PTRACE_SETHBPREGS
, pid
,
813 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
814 &proc_info
->bpts
[i
].address
) < 0)
815 perror_with_name ("Unexpected error setting breakpoint address");
817 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
818 if (ptrace (PTRACE_SETHBPREGS
, pid
,
819 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
820 &proc_info
->bpts
[i
].control
) < 0)
821 perror_with_name ("Unexpected error setting breakpoint");
823 lwp_info
->bpts_changed
[i
] = 0;
826 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
827 if (lwp_info
->wpts_changed
[i
])
831 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
832 if (ptrace (PTRACE_SETHBPREGS
, pid
,
833 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
834 &proc_info
->wpts
[i
].address
) < 0)
835 perror_with_name ("Unexpected error setting watchpoint address");
837 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
838 if (ptrace (PTRACE_SETHBPREGS
, pid
,
839 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
840 &proc_info
->wpts
[i
].control
) < 0)
841 perror_with_name ("Unexpected error setting watchpoint");
843 lwp_info
->wpts_changed
[i
] = 0;
847 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
848 addition, set IS_THUMB depending on whether we will return to ARM
850 See arm-linux.h for stack layout details. */
852 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
856 unsigned long sp_data
;
857 /* Offset of PC register. */
859 CORE_ADDR next_pc
= 0;
862 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
864 collect_register_by_name (regcache
, "sp", &sp
);
865 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
867 pc_offset
= arm_linux_sigreturn_next_pc_offset
868 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
870 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
872 /* Set IS_THUMB according the CPSR saved on the stack. */
873 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
874 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
879 /* When PC is at a syscall instruction, return the PC of the next
880 instruction to be executed. */
882 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
884 CORE_ADDR next_pc
= 0;
885 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
886 int is_thumb
= arm_is_thumb_mode ();
887 ULONGEST svc_number
= 0;
888 struct regcache
*regcache
= self
->regcache
;
892 collect_register (regcache
, 7, &svc_number
);
897 unsigned long this_instr
;
898 unsigned long svc_operand
;
900 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
901 svc_operand
= (0x00ffffff & this_instr
);
903 if (svc_operand
) /* OABI. */
905 svc_number
= svc_operand
- 0x900000;
909 collect_register (regcache
, 7, &svc_number
);
915 /* This is a sigreturn or sigreturn_rt syscall. */
916 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
918 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
920 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
923 /* Addresses for calling Thumb functions have the bit 0 set. */
925 next_pc
= MAKE_THUMB_ADDR (next_pc
);
930 static const struct target_desc
*
931 arm_read_description (void)
933 unsigned long arm_hwcap
= linux_get_hwcap (4);
935 if (arm_hwcap
& HWCAP_IWMMXT
)
936 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
938 if (arm_hwcap
& HWCAP_VFP
)
940 /* Make sure that the kernel supports reading VFP registers. Support was
942 int pid
= lwpid_of (current_thread
);
944 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
945 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
946 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
948 /* NEON implies either no VFP, or VFPv3-D32. We only support
950 if (arm_hwcap
& HWCAP_NEON
)
951 return aarch32_linux_read_description ();
952 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
953 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
955 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
958 /* The default configuration uses legacy FPA registers, probably
960 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
964 arm_target::low_arch_setup ()
966 int tid
= lwpid_of (current_thread
);
970 /* Query hardware watchpoint/breakpoint capabilities. */
971 arm_linux_init_hwbp_cap (tid
);
973 current_process ()->tdesc
= arm_read_description ();
975 iov
.iov_base
= gpregs
;
976 iov
.iov_len
= sizeof (gpregs
);
978 /* Check if PTRACE_GETREGSET works. */
979 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
980 have_ptrace_getregset
= 1;
982 have_ptrace_getregset
= 0;
986 arm_target::supports_software_single_step ()
991 /* Fetch the next possible PCs after the current instruction executes. */
993 std::vector
<CORE_ADDR
>
994 arm_target::low_get_next_pcs (regcache
*regcache
)
996 struct arm_get_next_pcs next_pcs_ctx
;
998 arm_get_next_pcs_ctor (&next_pcs_ctx
,
1000 /* Byte order is ignored assumed as host. */
1006 return arm_get_next_pcs (&next_pcs_ctx
);
1009 /* Support for hardware single step. */
1012 arm_supports_hardware_single_step (void)
1017 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1020 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1022 if (arm_is_thumb_mode ())
1023 collect_register_by_name (regcache
, "r7", sysno
);
1029 collect_register_by_name (regcache
, "pc", &pc
);
1031 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1032 *sysno
= UNKNOWN_SYSCALL
;
1035 unsigned long svc_operand
= (0x00ffffff & insn
);
1040 *sysno
= svc_operand
- 0x900000;
1045 collect_register_by_name (regcache
, "r7", sysno
);
1051 /* Register sets without using PTRACE_GETREGSET. */
1053 static struct regset_info arm_regsets
[] = {
1054 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1055 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1056 arm_fill_gregset
, arm_store_gregset
},
1057 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1058 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1059 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1060 arm_fill_vfpregset
, arm_store_vfpregset
},
1064 static struct regsets_info arm_regsets_info
=
1066 arm_regsets
, /* regsets */
1067 0, /* num_regsets */
1068 NULL
, /* disabled_regsets */
1071 static struct usrregs_info arm_usrregs_info
=
1077 static struct regs_info regs_info_arm
=
1079 NULL
, /* regset_bitmap */
1085 arm_target::get_regs_info ()
1087 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1089 if (have_ptrace_getregset
== 1
1090 && (is_aarch32_linux_description (tdesc
)
1091 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1092 return ®s_info_aarch32
;
1094 return ®s_info_arm
;
1097 struct linux_target_ops the_low_target
= {
1100 arm_stopped_by_watchpoint
,
1101 arm_stopped_data_address
,
1102 NULL
, /* collect_ptrace_register */
1103 NULL
, /* supply_ptrace_register */
1104 NULL
, /* siginfo_fixup */
1110 arm_prepare_to_resume
,
1111 NULL
, /* process_qsupported */
1112 NULL
, /* supports_tracepoints */
1113 NULL
, /* get_thread_area */
1114 NULL
, /* install_fast_tracepoint_jump_pad */
1115 NULL
, /* emit_ops */
1116 NULL
, /* get_min_fast_tracepoint_insn_len */
1117 NULL
, /* supports_range_stepping */
1118 arm_supports_hardware_single_step
,
1119 arm_get_syscall_trapinfo
,
1122 /* The linux target ops object. */
1124 linux_process_target
*the_linux_target
= &the_arm_target
;
1127 initialize_low_arch (void)
1129 initialize_low_arch_aarch32 ();
1130 initialize_regsets_info (&arm_regsets_info
);