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
;
103 arch_process_info
*low_new_process () override
;
105 void low_delete_process (arch_process_info
*info
) override
;
107 void low_new_thread (lwp_info
*) override
;
109 void low_delete_thread (arch_lwp_info
*) override
;
111 void low_new_fork (process_info
*parent
, process_info
*child
) override
;
114 /* The singleton target ops object. */
116 static arm_target the_arm_target
;
119 arm_target::low_supports_breakpoints ()
125 arm_target::low_get_pc (regcache
*regcache
)
127 return linux_get_pc_32bit (regcache
);
131 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
133 linux_set_pc_32bit (regcache
, pc
);
137 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
139 return arm_breakpoint_kind_from_pc (pcptr
);
143 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
145 return arm_breakpoint_kind_from_current_state (pcptr
);
149 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
151 return arm_sw_breakpoint_from_kind (kind
, size
);
155 arm_target::low_breakpoint_at (CORE_ADDR pc
)
157 return arm_breakpoint_at (pc
);
160 /* Information describing the hardware breakpoint capabilities. */
164 unsigned char max_wp_length
;
165 unsigned char wp_count
;
166 unsigned char bp_count
;
167 } arm_linux_hwbp_cap
;
169 /* Enum describing the different types of ARM hardware break-/watch-points. */
178 /* Type describing an ARM Hardware Breakpoint Control register value. */
179 typedef unsigned int arm_hwbp_control_t
;
181 /* Structure used to keep track of hardware break-/watch-points. */
182 struct arm_linux_hw_breakpoint
184 /* Address to break on, or being watched. */
185 unsigned int address
;
186 /* Control register for break-/watch- point. */
187 arm_hwbp_control_t control
;
190 /* Since we cannot dynamically allocate subfields of arch_process_info,
191 assume a maximum number of supported break-/watchpoints. */
195 /* Per-process arch-specific data we want to keep. */
196 struct arch_process_info
198 /* Hardware breakpoints for this process. */
199 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
200 /* Hardware watchpoints for this process. */
201 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
204 /* Per-thread arch-specific data we want to keep. */
207 /* Non-zero if our copy differs from what's recorded in the thread. */
208 char bpts_changed
[MAX_BPTS
];
209 char wpts_changed
[MAX_WPTS
];
210 /* Cached stopped data address. */
211 CORE_ADDR stopped_data_address
;
214 /* These are in <asm/elf.h> in current kernels. */
216 #define HWCAP_IWMMXT 512
217 #define HWCAP_NEON 4096
218 #define HWCAP_VFPv3 8192
219 #define HWCAP_VFPv3D16 16384
221 #ifdef HAVE_SYS_REG_H
225 #define arm_num_regs 26
227 static int arm_regmap
[] = {
228 0, 4, 8, 12, 16, 20, 24, 28,
229 32, 36, 40, 44, 48, 52, 56, 60,
230 -1, -1, -1, -1, -1, -1, -1, -1, -1,
234 /* Forward declarations needed for get_next_pcs ops. */
235 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
239 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
242 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
244 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
246 /* get_next_pcs operations. */
247 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
248 get_next_pcs_read_memory_unsigned_integer
,
249 get_next_pcs_syscall_next_pc
,
250 get_next_pcs_addr_bits_remove
,
251 get_next_pcs_is_thumb
,
252 arm_linux_get_next_pcs_fixup
,
256 arm_target::low_cannot_store_register (int regno
)
258 return (regno
>= arm_num_regs
);
262 arm_target::low_cannot_fetch_register (int regno
)
264 return (regno
>= arm_num_regs
);
268 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
270 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
273 for (int i
= 0; i
< 16; i
++)
274 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
276 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
277 for (int i
= 0; i
< 6; i
++)
278 collect_register (regcache
, arm_num_regs
+ i
+ 16,
279 (char *) buf
+ 16 * 8 + i
* 4);
283 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
285 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
288 for (int i
= 0; i
< 16; i
++)
289 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
291 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
292 for (int i
= 0; i
< 6; i
++)
293 supply_register (regcache
, arm_num_regs
+ i
+ 16,
294 (char *) buf
+ 16 * 8 + i
* 4);
298 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
302 if (is_aarch32_linux_description (regcache
->tdesc
))
306 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
308 if (fp_type
== ARM_FP_TYPE_VFPV3
)
310 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
316 arm_fill_vfpregset_num (regcache
, buf
, num
);
319 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
321 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
323 return UNMAKE_THUMB_ADDR (val
);
327 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
331 if (is_aarch32_linux_description (regcache
->tdesc
))
335 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
337 if (fp_type
== ARM_FP_TYPE_VFPV3
)
339 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
345 arm_store_vfpregset_num (regcache
, buf
, num
);
348 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
350 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
352 return arm_is_thumb_mode ();
355 /* Read memory from the inferior.
356 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
357 read_memory_unsigned_integer. */
359 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
366 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
371 /* Fetch the thread-local storage pointer for libthread_db. */
374 ps_get_thread_area (struct ps_prochandle
*ph
,
375 lwpid_t lwpid
, int idx
, void **base
)
377 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
380 /* IDX is the bias from the thread pointer to the beginning of the
381 thread descriptor. It has to be subtracted due to implementation
382 quirks in libthread_db. */
383 *base
= (void *) ((char *)*base
- idx
);
389 /* Query Hardware Breakpoint information for the target we are attached to
390 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
392 arm_linux_init_hwbp_cap (int pid
)
396 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
399 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
400 if (arm_linux_hwbp_cap
.arch
== 0)
403 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
404 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
405 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
407 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
408 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
409 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
410 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
413 /* How many hardware breakpoints are available? */
415 arm_linux_get_hw_breakpoint_count (void)
417 return arm_linux_hwbp_cap
.bp_count
;
420 /* How many hardware watchpoints are available? */
422 arm_linux_get_hw_watchpoint_count (void)
424 return arm_linux_hwbp_cap
.wp_count
;
427 /* Maximum length of area watched by hardware watchpoint. */
429 arm_linux_get_hw_watchpoint_max_length (void)
431 return arm_linux_hwbp_cap
.max_wp_length
;
434 /* Initialize an ARM hardware break-/watch-point control register value.
435 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
436 type of break-/watch-point; ENABLE indicates whether the point is enabled.
438 static arm_hwbp_control_t
439 arm_hwbp_control_initialize (unsigned byte_address_select
,
440 arm_hwbp_type hwbp_type
,
443 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
444 gdb_assert (hwbp_type
!= arm_hwbp_break
445 || ((byte_address_select
& 0xfU
) != 0));
447 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
450 /* Does the breakpoint control value CONTROL have the enable bit set? */
452 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
454 return control
& 0x1;
457 /* Is the breakpoint control value CONTROL initialized? */
459 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
464 /* Change a breakpoint control word so that it is in the disabled state. */
465 static arm_hwbp_control_t
466 arm_hwbp_control_disable (arm_hwbp_control_t control
)
468 return control
& ~0x1;
471 /* Are two break-/watch-points equal? */
473 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
474 const struct arm_linux_hw_breakpoint
*p2
)
476 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
479 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
482 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
486 case raw_bkpt_type_hw
:
487 return arm_hwbp_break
;
488 case raw_bkpt_type_write_wp
:
489 return arm_hwbp_store
;
490 case raw_bkpt_type_read_wp
:
491 return arm_hwbp_load
;
492 case raw_bkpt_type_access_wp
:
493 return arm_hwbp_access
;
495 gdb_assert_not_reached ("unhandled raw type");
499 /* Initialize the hardware breakpoint structure P for a breakpoint or
500 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
501 Returns -1 if TYPE is unsupported, or -2 if the particular combination
502 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
503 represents a breakpoint and 1 if type represents a watchpoint. */
505 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
506 int len
, struct arm_linux_hw_breakpoint
*p
)
508 arm_hwbp_type hwbp_type
;
511 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
513 if (hwbp_type
== arm_hwbp_break
)
515 /* For breakpoints, the length field encodes the mode. */
518 case 2: /* 16-bit Thumb mode breakpoint */
519 case 3: /* 32-bit Thumb mode breakpoint */
523 case 4: /* 32-bit ARM mode breakpoint */
534 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
535 CORE_ADDR aligned_addr
;
537 /* Can not set watchpoints for zero or negative lengths. */
540 /* The current ptrace interface can only handle watchpoints that are a
542 if ((len
& (len
- 1)) != 0)
545 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
546 range covered by a watchpoint. */
547 aligned_addr
= addr
& ~(max_wp_length
- 1);
548 if (aligned_addr
+ max_wp_length
< addr
+ len
)
551 mask
= (1 << len
) - 1;
554 p
->address
= (unsigned int) addr
;
555 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
557 return hwbp_type
!= arm_hwbp_break
;
560 /* Callback to mark a watch-/breakpoint to be updated in all threads of
561 the current process. */
564 update_registers_callback (thread_info
*thread
, int watch
, int i
)
566 struct lwp_info
*lwp
= get_thread_lwp (thread
);
568 /* The actual update is done later just before resuming the lwp,
569 we just mark that the registers need updating. */
571 lwp
->arch_private
->wpts_changed
[i
] = 1;
573 lwp
->arch_private
->bpts_changed
[i
] = 1;
575 /* If the lwp isn't stopped, force it to momentarily pause, so
576 we can update its breakpoint registers. */
578 linux_stop_lwp (lwp
);
582 arm_target::supports_z_point_type (char z_type
)
588 case Z_PACKET_WRITE_WP
:
589 case Z_PACKET_READ_WP
:
590 case Z_PACKET_ACCESS_WP
:
593 /* Leave the handling of sw breakpoints with the gdb client. */
598 /* Insert hardware break-/watchpoint. */
600 arm_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
601 int len
, raw_breakpoint
*bp
)
603 struct process_info
*proc
= current_process ();
604 struct arm_linux_hw_breakpoint p
, *pts
;
607 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
611 return watch
== -1 ? 1 : -1;
616 count
= arm_linux_get_hw_watchpoint_count ();
617 pts
= proc
->priv
->arch_private
->wpts
;
621 count
= arm_linux_get_hw_breakpoint_count ();
622 pts
= proc
->priv
->arch_private
->bpts
;
625 for (i
= 0; i
< count
; i
++)
626 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
630 /* Only update the threads of the current process. */
631 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
633 update_registers_callback (thread
, watch
, i
);
639 /* We're out of watchpoints. */
643 /* Remove hardware break-/watchpoint. */
645 arm_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
646 int len
, raw_breakpoint
*bp
)
648 struct process_info
*proc
= current_process ();
649 struct arm_linux_hw_breakpoint p
, *pts
;
652 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
661 count
= arm_linux_get_hw_watchpoint_count ();
662 pts
= proc
->priv
->arch_private
->wpts
;
666 count
= arm_linux_get_hw_breakpoint_count ();
667 pts
= proc
->priv
->arch_private
->bpts
;
670 for (i
= 0; i
< count
; i
++)
671 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
673 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
675 /* Only update the threads of the current process. */
676 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
678 update_registers_callback (thread
, watch
, i
);
684 /* No watchpoint matched. */
688 /* Return whether current thread is stopped due to a watchpoint. */
690 arm_target::low_stopped_by_watchpoint ()
692 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
695 /* We must be able to set hardware watchpoints. */
696 if (arm_linux_get_hw_watchpoint_count () == 0)
699 /* Retrieve siginfo. */
701 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
705 /* This must be a hardware breakpoint. */
706 if (siginfo
.si_signo
!= SIGTRAP
707 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
710 /* If we are in a positive slot then we're looking at a breakpoint and not
712 if (siginfo
.si_errno
>= 0)
715 /* Cache stopped data address for use by arm_stopped_data_address. */
716 lwp
->arch_private
->stopped_data_address
717 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
722 /* Return data address that triggered watchpoint. Called only if
723 low_stopped_by_watchpoint returned true. */
725 arm_target::low_stopped_data_address ()
727 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
728 return lwp
->arch_private
->stopped_data_address
;
731 /* Called when a new process is created. */
733 arm_target::low_new_process ()
735 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
739 /* Called when a process is being deleted. */
742 arm_target::low_delete_process (arch_process_info
*info
)
747 /* Called when a new thread is detected. */
749 arm_target::low_new_thread (lwp_info
*lwp
)
751 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
754 for (i
= 0; i
< MAX_BPTS
; i
++)
755 info
->bpts_changed
[i
] = 1;
756 for (i
= 0; i
< MAX_WPTS
; i
++)
757 info
->wpts_changed
[i
] = 1;
759 lwp
->arch_private
= info
;
762 /* Function to call when a thread is being deleted. */
765 arm_target::low_delete_thread (arch_lwp_info
*arch_lwp
)
771 arm_target::low_new_fork (process_info
*parent
, process_info
*child
)
773 struct arch_process_info
*parent_proc_info
;
774 struct arch_process_info
*child_proc_info
;
775 struct lwp_info
*child_lwp
;
776 struct arch_lwp_info
*child_lwp_info
;
779 /* These are allocated by linux_add_process. */
780 gdb_assert (parent
->priv
!= NULL
781 && parent
->priv
->arch_private
!= NULL
);
782 gdb_assert (child
->priv
!= NULL
783 && child
->priv
->arch_private
!= NULL
);
785 parent_proc_info
= parent
->priv
->arch_private
;
786 child_proc_info
= child
->priv
->arch_private
;
788 /* Linux kernel before 2.6.33 commit
789 72f674d203cd230426437cdcf7dd6f681dad8b0d
790 will inherit hardware debug registers from parent
791 on fork/vfork/clone. Newer Linux kernels create such tasks with
792 zeroed debug registers.
794 GDB core assumes the child inherits the watchpoints/hw
795 breakpoints of the parent, and will remove them all from the
796 forked off process. Copy the debug registers mirrors into the
797 new process so that all breakpoints and watchpoints can be
798 removed together. The debug registers mirror will become zeroed
799 in the end before detaching the forked off process, thus making
800 this compatible with older Linux kernels too. */
802 *child_proc_info
= *parent_proc_info
;
804 /* Mark all the hardware breakpoints and watchpoints as changed to
805 make sure that the registers will be updated. */
806 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
807 child_lwp_info
= child_lwp
->arch_private
;
808 for (i
= 0; i
< MAX_BPTS
; i
++)
809 child_lwp_info
->bpts_changed
[i
] = 1;
810 for (i
= 0; i
< MAX_WPTS
; i
++)
811 child_lwp_info
->wpts_changed
[i
] = 1;
814 /* Called when resuming a thread.
815 If the debug regs have changed, update the thread's copies. */
817 arm_prepare_to_resume (struct lwp_info
*lwp
)
819 struct thread_info
*thread
= get_lwp_thread (lwp
);
820 int pid
= lwpid_of (thread
);
821 struct process_info
*proc
= find_process_pid (pid_of (thread
));
822 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
823 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
826 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
827 if (lwp_info
->bpts_changed
[i
])
831 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
832 if (ptrace (PTRACE_SETHBPREGS
, pid
,
833 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
834 &proc_info
->bpts
[i
].address
) < 0)
835 perror_with_name ("Unexpected error setting breakpoint address");
837 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
838 if (ptrace (PTRACE_SETHBPREGS
, pid
,
839 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
840 &proc_info
->bpts
[i
].control
) < 0)
841 perror_with_name ("Unexpected error setting breakpoint");
843 lwp_info
->bpts_changed
[i
] = 0;
846 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
847 if (lwp_info
->wpts_changed
[i
])
851 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
852 if (ptrace (PTRACE_SETHBPREGS
, pid
,
853 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
854 &proc_info
->wpts
[i
].address
) < 0)
855 perror_with_name ("Unexpected error setting watchpoint address");
857 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
858 if (ptrace (PTRACE_SETHBPREGS
, pid
,
859 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
860 &proc_info
->wpts
[i
].control
) < 0)
861 perror_with_name ("Unexpected error setting watchpoint");
863 lwp_info
->wpts_changed
[i
] = 0;
867 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
868 addition, set IS_THUMB depending on whether we will return to ARM
870 See arm-linux.h for stack layout details. */
872 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
876 unsigned long sp_data
;
877 /* Offset of PC register. */
879 CORE_ADDR next_pc
= 0;
882 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
884 collect_register_by_name (regcache
, "sp", &sp
);
885 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
887 pc_offset
= arm_linux_sigreturn_next_pc_offset
888 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
890 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
892 /* Set IS_THUMB according the CPSR saved on the stack. */
893 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
894 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
899 /* When PC is at a syscall instruction, return the PC of the next
900 instruction to be executed. */
902 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
904 CORE_ADDR next_pc
= 0;
905 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
906 int is_thumb
= arm_is_thumb_mode ();
907 ULONGEST svc_number
= 0;
908 struct regcache
*regcache
= self
->regcache
;
912 collect_register (regcache
, 7, &svc_number
);
917 unsigned long this_instr
;
918 unsigned long svc_operand
;
920 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
921 svc_operand
= (0x00ffffff & this_instr
);
923 if (svc_operand
) /* OABI. */
925 svc_number
= svc_operand
- 0x900000;
929 collect_register (regcache
, 7, &svc_number
);
935 /* This is a sigreturn or sigreturn_rt syscall. */
936 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
938 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
940 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
943 /* Addresses for calling Thumb functions have the bit 0 set. */
945 next_pc
= MAKE_THUMB_ADDR (next_pc
);
950 static const struct target_desc
*
951 arm_read_description (void)
953 unsigned long arm_hwcap
= linux_get_hwcap (4);
955 if (arm_hwcap
& HWCAP_IWMMXT
)
956 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
958 if (arm_hwcap
& HWCAP_VFP
)
960 /* Make sure that the kernel supports reading VFP registers. Support was
962 int pid
= lwpid_of (current_thread
);
964 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
965 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
966 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
968 /* NEON implies either no VFP, or VFPv3-D32. We only support
970 if (arm_hwcap
& HWCAP_NEON
)
971 return aarch32_linux_read_description ();
972 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
973 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
975 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
978 /* The default configuration uses legacy FPA registers, probably
980 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
984 arm_target::low_arch_setup ()
986 int tid
= lwpid_of (current_thread
);
990 /* Query hardware watchpoint/breakpoint capabilities. */
991 arm_linux_init_hwbp_cap (tid
);
993 current_process ()->tdesc
= arm_read_description ();
995 iov
.iov_base
= gpregs
;
996 iov
.iov_len
= sizeof (gpregs
);
998 /* Check if PTRACE_GETREGSET works. */
999 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
1000 have_ptrace_getregset
= 1;
1002 have_ptrace_getregset
= 0;
1006 arm_target::supports_software_single_step ()
1011 /* Fetch the next possible PCs after the current instruction executes. */
1013 std::vector
<CORE_ADDR
>
1014 arm_target::low_get_next_pcs (regcache
*regcache
)
1016 struct arm_get_next_pcs next_pcs_ctx
;
1018 arm_get_next_pcs_ctor (&next_pcs_ctx
,
1020 /* Byte order is ignored assumed as host. */
1026 return arm_get_next_pcs (&next_pcs_ctx
);
1029 /* Support for hardware single step. */
1032 arm_supports_hardware_single_step (void)
1037 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1040 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1042 if (arm_is_thumb_mode ())
1043 collect_register_by_name (regcache
, "r7", sysno
);
1049 collect_register_by_name (regcache
, "pc", &pc
);
1051 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1052 *sysno
= UNKNOWN_SYSCALL
;
1055 unsigned long svc_operand
= (0x00ffffff & insn
);
1060 *sysno
= svc_operand
- 0x900000;
1065 collect_register_by_name (regcache
, "r7", sysno
);
1071 /* Register sets without using PTRACE_GETREGSET. */
1073 static struct regset_info arm_regsets
[] = {
1074 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1075 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1076 arm_fill_gregset
, arm_store_gregset
},
1077 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1078 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1079 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1080 arm_fill_vfpregset
, arm_store_vfpregset
},
1084 static struct regsets_info arm_regsets_info
=
1086 arm_regsets
, /* regsets */
1087 0, /* num_regsets */
1088 NULL
, /* disabled_regsets */
1091 static struct usrregs_info arm_usrregs_info
=
1097 static struct regs_info regs_info_arm
=
1099 NULL
, /* regset_bitmap */
1105 arm_target::get_regs_info ()
1107 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1109 if (have_ptrace_getregset
== 1
1110 && (is_aarch32_linux_description (tdesc
)
1111 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1112 return ®s_info_aarch32
;
1114 return ®s_info_arm
;
1117 struct linux_target_ops the_low_target
= {
1118 arm_prepare_to_resume
,
1119 NULL
, /* process_qsupported */
1120 NULL
, /* supports_tracepoints */
1121 NULL
, /* get_thread_area */
1122 NULL
, /* install_fast_tracepoint_jump_pad */
1123 NULL
, /* emit_ops */
1124 NULL
, /* get_min_fast_tracepoint_insn_len */
1125 NULL
, /* supports_range_stepping */
1126 arm_supports_hardware_single_step
,
1127 arm_get_syscall_trapinfo
,
1130 /* The linux target ops object. */
1132 linux_process_target
*the_linux_target
= &the_arm_target
;
1135 initialize_low_arch (void)
1137 initialize_low_arch_aarch32 ();
1138 initialize_regsets_info (&arm_regsets_info
);