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
;
99 bool low_stopped_by_watchpoint () override
;
101 CORE_ADDR
low_stopped_data_address () override
;
104 /* The singleton target ops object. */
106 static arm_target the_arm_target
;
109 arm_target::low_supports_breakpoints ()
115 arm_target::low_get_pc (regcache
*regcache
)
117 return linux_get_pc_32bit (regcache
);
121 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
123 linux_set_pc_32bit (regcache
, pc
);
127 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
129 return arm_breakpoint_kind_from_pc (pcptr
);
133 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
135 return arm_breakpoint_kind_from_current_state (pcptr
);
139 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
141 return arm_sw_breakpoint_from_kind (kind
, size
);
145 arm_target::low_breakpoint_at (CORE_ADDR pc
)
147 return arm_breakpoint_at (pc
);
150 /* Information describing the hardware breakpoint capabilities. */
154 unsigned char max_wp_length
;
155 unsigned char wp_count
;
156 unsigned char bp_count
;
157 } arm_linux_hwbp_cap
;
159 /* Enum describing the different types of ARM hardware break-/watch-points. */
168 /* Type describing an ARM Hardware Breakpoint Control register value. */
169 typedef unsigned int arm_hwbp_control_t
;
171 /* Structure used to keep track of hardware break-/watch-points. */
172 struct arm_linux_hw_breakpoint
174 /* Address to break on, or being watched. */
175 unsigned int address
;
176 /* Control register for break-/watch- point. */
177 arm_hwbp_control_t control
;
180 /* Since we cannot dynamically allocate subfields of arch_process_info,
181 assume a maximum number of supported break-/watchpoints. */
185 /* Per-process arch-specific data we want to keep. */
186 struct arch_process_info
188 /* Hardware breakpoints for this process. */
189 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
190 /* Hardware watchpoints for this process. */
191 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
194 /* Per-thread arch-specific data we want to keep. */
197 /* Non-zero if our copy differs from what's recorded in the thread. */
198 char bpts_changed
[MAX_BPTS
];
199 char wpts_changed
[MAX_WPTS
];
200 /* Cached stopped data address. */
201 CORE_ADDR stopped_data_address
;
204 /* These are in <asm/elf.h> in current kernels. */
206 #define HWCAP_IWMMXT 512
207 #define HWCAP_NEON 4096
208 #define HWCAP_VFPv3 8192
209 #define HWCAP_VFPv3D16 16384
211 #ifdef HAVE_SYS_REG_H
215 #define arm_num_regs 26
217 static int arm_regmap
[] = {
218 0, 4, 8, 12, 16, 20, 24, 28,
219 32, 36, 40, 44, 48, 52, 56, 60,
220 -1, -1, -1, -1, -1, -1, -1, -1, -1,
224 /* Forward declarations needed for get_next_pcs ops. */
225 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
229 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
232 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
234 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
236 /* get_next_pcs operations. */
237 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
238 get_next_pcs_read_memory_unsigned_integer
,
239 get_next_pcs_syscall_next_pc
,
240 get_next_pcs_addr_bits_remove
,
241 get_next_pcs_is_thumb
,
242 arm_linux_get_next_pcs_fixup
,
246 arm_target::low_cannot_store_register (int regno
)
248 return (regno
>= arm_num_regs
);
252 arm_target::low_cannot_fetch_register (int regno
)
254 return (regno
>= arm_num_regs
);
258 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
260 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
263 for (int i
= 0; i
< 16; i
++)
264 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
266 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
267 for (int i
= 0; i
< 6; i
++)
268 collect_register (regcache
, arm_num_regs
+ i
+ 16,
269 (char *) buf
+ 16 * 8 + i
* 4);
273 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
275 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
278 for (int i
= 0; i
< 16; i
++)
279 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
281 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
282 for (int i
= 0; i
< 6; i
++)
283 supply_register (regcache
, arm_num_regs
+ i
+ 16,
284 (char *) buf
+ 16 * 8 + i
* 4);
288 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
292 if (is_aarch32_linux_description (regcache
->tdesc
))
296 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
298 if (fp_type
== ARM_FP_TYPE_VFPV3
)
300 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
306 arm_fill_vfpregset_num (regcache
, buf
, num
);
309 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
311 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
313 return UNMAKE_THUMB_ADDR (val
);
317 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
321 if (is_aarch32_linux_description (regcache
->tdesc
))
325 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
327 if (fp_type
== ARM_FP_TYPE_VFPV3
)
329 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
335 arm_store_vfpregset_num (regcache
, buf
, num
);
338 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
340 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
342 return arm_is_thumb_mode ();
345 /* Read memory from the inferior.
346 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
347 read_memory_unsigned_integer. */
349 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
356 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
361 /* Fetch the thread-local storage pointer for libthread_db. */
364 ps_get_thread_area (struct ps_prochandle
*ph
,
365 lwpid_t lwpid
, int idx
, void **base
)
367 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
370 /* IDX is the bias from the thread pointer to the beginning of the
371 thread descriptor. It has to be subtracted due to implementation
372 quirks in libthread_db. */
373 *base
= (void *) ((char *)*base
- idx
);
379 /* Query Hardware Breakpoint information for the target we are attached to
380 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
382 arm_linux_init_hwbp_cap (int pid
)
386 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
389 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
390 if (arm_linux_hwbp_cap
.arch
== 0)
393 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
394 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
395 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
397 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
398 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
399 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
400 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
403 /* How many hardware breakpoints are available? */
405 arm_linux_get_hw_breakpoint_count (void)
407 return arm_linux_hwbp_cap
.bp_count
;
410 /* How many hardware watchpoints are available? */
412 arm_linux_get_hw_watchpoint_count (void)
414 return arm_linux_hwbp_cap
.wp_count
;
417 /* Maximum length of area watched by hardware watchpoint. */
419 arm_linux_get_hw_watchpoint_max_length (void)
421 return arm_linux_hwbp_cap
.max_wp_length
;
424 /* Initialize an ARM hardware break-/watch-point control register value.
425 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
426 type of break-/watch-point; ENABLE indicates whether the point is enabled.
428 static arm_hwbp_control_t
429 arm_hwbp_control_initialize (unsigned byte_address_select
,
430 arm_hwbp_type hwbp_type
,
433 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
434 gdb_assert (hwbp_type
!= arm_hwbp_break
435 || ((byte_address_select
& 0xfU
) != 0));
437 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
440 /* Does the breakpoint control value CONTROL have the enable bit set? */
442 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
444 return control
& 0x1;
447 /* Is the breakpoint control value CONTROL initialized? */
449 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
454 /* Change a breakpoint control word so that it is in the disabled state. */
455 static arm_hwbp_control_t
456 arm_hwbp_control_disable (arm_hwbp_control_t control
)
458 return control
& ~0x1;
461 /* Are two break-/watch-points equal? */
463 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
464 const struct arm_linux_hw_breakpoint
*p2
)
466 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
469 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
472 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
476 case raw_bkpt_type_hw
:
477 return arm_hwbp_break
;
478 case raw_bkpt_type_write_wp
:
479 return arm_hwbp_store
;
480 case raw_bkpt_type_read_wp
:
481 return arm_hwbp_load
;
482 case raw_bkpt_type_access_wp
:
483 return arm_hwbp_access
;
485 gdb_assert_not_reached ("unhandled raw type");
489 /* Initialize the hardware breakpoint structure P for a breakpoint or
490 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
491 Returns -1 if TYPE is unsupported, or -2 if the particular combination
492 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
493 represents a breakpoint and 1 if type represents a watchpoint. */
495 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
496 int len
, struct arm_linux_hw_breakpoint
*p
)
498 arm_hwbp_type hwbp_type
;
501 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
503 if (hwbp_type
== arm_hwbp_break
)
505 /* For breakpoints, the length field encodes the mode. */
508 case 2: /* 16-bit Thumb mode breakpoint */
509 case 3: /* 32-bit Thumb mode breakpoint */
513 case 4: /* 32-bit ARM mode breakpoint */
524 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
525 CORE_ADDR aligned_addr
;
527 /* Can not set watchpoints for zero or negative lengths. */
530 /* The current ptrace interface can only handle watchpoints that are a
532 if ((len
& (len
- 1)) != 0)
535 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
536 range covered by a watchpoint. */
537 aligned_addr
= addr
& ~(max_wp_length
- 1);
538 if (aligned_addr
+ max_wp_length
< addr
+ len
)
541 mask
= (1 << len
) - 1;
544 p
->address
= (unsigned int) addr
;
545 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
547 return hwbp_type
!= arm_hwbp_break
;
550 /* Callback to mark a watch-/breakpoint to be updated in all threads of
551 the current process. */
554 update_registers_callback (thread_info
*thread
, int watch
, int i
)
556 struct lwp_info
*lwp
= get_thread_lwp (thread
);
558 /* The actual update is done later just before resuming the lwp,
559 we just mark that the registers need updating. */
561 lwp
->arch_private
->wpts_changed
[i
] = 1;
563 lwp
->arch_private
->bpts_changed
[i
] = 1;
565 /* If the lwp isn't stopped, force it to momentarily pause, so
566 we can update its breakpoint registers. */
568 linux_stop_lwp (lwp
);
572 arm_target::supports_z_point_type (char z_type
)
578 case Z_PACKET_WRITE_WP
:
579 case Z_PACKET_READ_WP
:
580 case Z_PACKET_ACCESS_WP
:
583 /* Leave the handling of sw breakpoints with the gdb client. */
588 /* Insert hardware break-/watchpoint. */
590 arm_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
591 int len
, raw_breakpoint
*bp
)
593 struct process_info
*proc
= current_process ();
594 struct arm_linux_hw_breakpoint p
, *pts
;
597 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
601 return watch
== -1 ? 1 : -1;
606 count
= arm_linux_get_hw_watchpoint_count ();
607 pts
= proc
->priv
->arch_private
->wpts
;
611 count
= arm_linux_get_hw_breakpoint_count ();
612 pts
= proc
->priv
->arch_private
->bpts
;
615 for (i
= 0; i
< count
; i
++)
616 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
620 /* Only update the threads of the current process. */
621 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
623 update_registers_callback (thread
, watch
, i
);
629 /* We're out of watchpoints. */
633 /* Remove hardware break-/watchpoint. */
635 arm_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
636 int len
, raw_breakpoint
*bp
)
638 struct process_info
*proc
= current_process ();
639 struct arm_linux_hw_breakpoint p
, *pts
;
642 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
651 count
= arm_linux_get_hw_watchpoint_count ();
652 pts
= proc
->priv
->arch_private
->wpts
;
656 count
= arm_linux_get_hw_breakpoint_count ();
657 pts
= proc
->priv
->arch_private
->bpts
;
660 for (i
= 0; i
< count
; i
++)
661 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
663 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
665 /* Only update the threads of the current process. */
666 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
668 update_registers_callback (thread
, watch
, i
);
674 /* No watchpoint matched. */
678 /* Return whether current thread is stopped due to a watchpoint. */
680 arm_target::low_stopped_by_watchpoint ()
682 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
685 /* We must be able to set hardware watchpoints. */
686 if (arm_linux_get_hw_watchpoint_count () == 0)
689 /* Retrieve siginfo. */
691 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
695 /* This must be a hardware breakpoint. */
696 if (siginfo
.si_signo
!= SIGTRAP
697 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
700 /* If we are in a positive slot then we're looking at a breakpoint and not
702 if (siginfo
.si_errno
>= 0)
705 /* Cache stopped data address for use by arm_stopped_data_address. */
706 lwp
->arch_private
->stopped_data_address
707 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
712 /* Return data address that triggered watchpoint. Called only if
713 low_stopped_by_watchpoint returned true. */
715 arm_target::low_stopped_data_address ()
717 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
718 return lwp
->arch_private
->stopped_data_address
;
721 /* Called when a new process is created. */
722 static struct arch_process_info
*
723 arm_new_process (void)
725 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
729 /* Called when a process is being deleted. */
732 arm_delete_process (struct arch_process_info
*info
)
737 /* Called when a new thread is detected. */
739 arm_new_thread (struct lwp_info
*lwp
)
741 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
744 for (i
= 0; i
< MAX_BPTS
; i
++)
745 info
->bpts_changed
[i
] = 1;
746 for (i
= 0; i
< MAX_WPTS
; i
++)
747 info
->wpts_changed
[i
] = 1;
749 lwp
->arch_private
= info
;
752 /* Function to call when a thread is being deleted. */
755 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
761 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
763 struct arch_process_info
*parent_proc_info
;
764 struct arch_process_info
*child_proc_info
;
765 struct lwp_info
*child_lwp
;
766 struct arch_lwp_info
*child_lwp_info
;
769 /* These are allocated by linux_add_process. */
770 gdb_assert (parent
->priv
!= NULL
771 && parent
->priv
->arch_private
!= NULL
);
772 gdb_assert (child
->priv
!= NULL
773 && child
->priv
->arch_private
!= NULL
);
775 parent_proc_info
= parent
->priv
->arch_private
;
776 child_proc_info
= child
->priv
->arch_private
;
778 /* Linux kernel before 2.6.33 commit
779 72f674d203cd230426437cdcf7dd6f681dad8b0d
780 will inherit hardware debug registers from parent
781 on fork/vfork/clone. Newer Linux kernels create such tasks with
782 zeroed debug registers.
784 GDB core assumes the child inherits the watchpoints/hw
785 breakpoints of the parent, and will remove them all from the
786 forked off process. Copy the debug registers mirrors into the
787 new process so that all breakpoints and watchpoints can be
788 removed together. The debug registers mirror will become zeroed
789 in the end before detaching the forked off process, thus making
790 this compatible with older Linux kernels too. */
792 *child_proc_info
= *parent_proc_info
;
794 /* Mark all the hardware breakpoints and watchpoints as changed to
795 make sure that the registers will be updated. */
796 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
797 child_lwp_info
= child_lwp
->arch_private
;
798 for (i
= 0; i
< MAX_BPTS
; i
++)
799 child_lwp_info
->bpts_changed
[i
] = 1;
800 for (i
= 0; i
< MAX_WPTS
; i
++)
801 child_lwp_info
->wpts_changed
[i
] = 1;
804 /* Called when resuming a thread.
805 If the debug regs have changed, update the thread's copies. */
807 arm_prepare_to_resume (struct lwp_info
*lwp
)
809 struct thread_info
*thread
= get_lwp_thread (lwp
);
810 int pid
= lwpid_of (thread
);
811 struct process_info
*proc
= find_process_pid (pid_of (thread
));
812 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
813 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
816 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
817 if (lwp_info
->bpts_changed
[i
])
821 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
822 if (ptrace (PTRACE_SETHBPREGS
, pid
,
823 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
824 &proc_info
->bpts
[i
].address
) < 0)
825 perror_with_name ("Unexpected error setting breakpoint address");
827 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
828 if (ptrace (PTRACE_SETHBPREGS
, pid
,
829 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
830 &proc_info
->bpts
[i
].control
) < 0)
831 perror_with_name ("Unexpected error setting breakpoint");
833 lwp_info
->bpts_changed
[i
] = 0;
836 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
837 if (lwp_info
->wpts_changed
[i
])
841 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
842 if (ptrace (PTRACE_SETHBPREGS
, pid
,
843 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
844 &proc_info
->wpts
[i
].address
) < 0)
845 perror_with_name ("Unexpected error setting watchpoint address");
847 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
848 if (ptrace (PTRACE_SETHBPREGS
, pid
,
849 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
850 &proc_info
->wpts
[i
].control
) < 0)
851 perror_with_name ("Unexpected error setting watchpoint");
853 lwp_info
->wpts_changed
[i
] = 0;
857 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
858 addition, set IS_THUMB depending on whether we will return to ARM
860 See arm-linux.h for stack layout details. */
862 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
866 unsigned long sp_data
;
867 /* Offset of PC register. */
869 CORE_ADDR next_pc
= 0;
872 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
874 collect_register_by_name (regcache
, "sp", &sp
);
875 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
877 pc_offset
= arm_linux_sigreturn_next_pc_offset
878 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
880 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
882 /* Set IS_THUMB according the CPSR saved on the stack. */
883 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
884 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
889 /* When PC is at a syscall instruction, return the PC of the next
890 instruction to be executed. */
892 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
894 CORE_ADDR next_pc
= 0;
895 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
896 int is_thumb
= arm_is_thumb_mode ();
897 ULONGEST svc_number
= 0;
898 struct regcache
*regcache
= self
->regcache
;
902 collect_register (regcache
, 7, &svc_number
);
907 unsigned long this_instr
;
908 unsigned long svc_operand
;
910 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
911 svc_operand
= (0x00ffffff & this_instr
);
913 if (svc_operand
) /* OABI. */
915 svc_number
= svc_operand
- 0x900000;
919 collect_register (regcache
, 7, &svc_number
);
925 /* This is a sigreturn or sigreturn_rt syscall. */
926 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
928 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
930 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
933 /* Addresses for calling Thumb functions have the bit 0 set. */
935 next_pc
= MAKE_THUMB_ADDR (next_pc
);
940 static const struct target_desc
*
941 arm_read_description (void)
943 unsigned long arm_hwcap
= linux_get_hwcap (4);
945 if (arm_hwcap
& HWCAP_IWMMXT
)
946 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
948 if (arm_hwcap
& HWCAP_VFP
)
950 /* Make sure that the kernel supports reading VFP registers. Support was
952 int pid
= lwpid_of (current_thread
);
954 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
955 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
956 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
958 /* NEON implies either no VFP, or VFPv3-D32. We only support
960 if (arm_hwcap
& HWCAP_NEON
)
961 return aarch32_linux_read_description ();
962 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
963 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
965 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
968 /* The default configuration uses legacy FPA registers, probably
970 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
974 arm_target::low_arch_setup ()
976 int tid
= lwpid_of (current_thread
);
980 /* Query hardware watchpoint/breakpoint capabilities. */
981 arm_linux_init_hwbp_cap (tid
);
983 current_process ()->tdesc
= arm_read_description ();
985 iov
.iov_base
= gpregs
;
986 iov
.iov_len
= sizeof (gpregs
);
988 /* Check if PTRACE_GETREGSET works. */
989 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
990 have_ptrace_getregset
= 1;
992 have_ptrace_getregset
= 0;
996 arm_target::supports_software_single_step ()
1001 /* Fetch the next possible PCs after the current instruction executes. */
1003 std::vector
<CORE_ADDR
>
1004 arm_target::low_get_next_pcs (regcache
*regcache
)
1006 struct arm_get_next_pcs next_pcs_ctx
;
1008 arm_get_next_pcs_ctor (&next_pcs_ctx
,
1010 /* Byte order is ignored assumed as host. */
1016 return arm_get_next_pcs (&next_pcs_ctx
);
1019 /* Support for hardware single step. */
1022 arm_supports_hardware_single_step (void)
1027 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1030 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1032 if (arm_is_thumb_mode ())
1033 collect_register_by_name (regcache
, "r7", sysno
);
1039 collect_register_by_name (regcache
, "pc", &pc
);
1041 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1042 *sysno
= UNKNOWN_SYSCALL
;
1045 unsigned long svc_operand
= (0x00ffffff & insn
);
1050 *sysno
= svc_operand
- 0x900000;
1055 collect_register_by_name (regcache
, "r7", sysno
);
1061 /* Register sets without using PTRACE_GETREGSET. */
1063 static struct regset_info arm_regsets
[] = {
1064 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1065 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1066 arm_fill_gregset
, arm_store_gregset
},
1067 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1068 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1069 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1070 arm_fill_vfpregset
, arm_store_vfpregset
},
1074 static struct regsets_info arm_regsets_info
=
1076 arm_regsets
, /* regsets */
1077 0, /* num_regsets */
1078 NULL
, /* disabled_regsets */
1081 static struct usrregs_info arm_usrregs_info
=
1087 static struct regs_info regs_info_arm
=
1089 NULL
, /* regset_bitmap */
1095 arm_target::get_regs_info ()
1097 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1099 if (have_ptrace_getregset
== 1
1100 && (is_aarch32_linux_description (tdesc
)
1101 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1102 return ®s_info_aarch32
;
1104 return ®s_info_arm
;
1107 struct linux_target_ops the_low_target
= {
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
);