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
;
71 void low_arch_setup () override
;
73 bool low_cannot_fetch_register (int regno
) override
;
75 bool low_cannot_store_register (int regno
) override
;
77 bool low_supports_breakpoints () override
;
79 CORE_ADDR
low_get_pc (regcache
*regcache
) override
;
81 void low_set_pc (regcache
*regcache
, CORE_ADDR newpc
) override
;
84 /* The singleton target ops object. */
86 static arm_target the_arm_target
;
89 arm_target::low_supports_breakpoints ()
95 arm_target::low_get_pc (regcache
*regcache
)
97 return linux_get_pc_32bit (regcache
);
101 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
103 linux_set_pc_32bit (regcache
, pc
);
107 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
109 return arm_breakpoint_kind_from_pc (pcptr
);
113 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
115 return arm_breakpoint_kind_from_current_state (pcptr
);
118 /* Information describing the hardware breakpoint capabilities. */
122 unsigned char max_wp_length
;
123 unsigned char wp_count
;
124 unsigned char bp_count
;
125 } arm_linux_hwbp_cap
;
127 /* Enum describing the different types of ARM hardware break-/watch-points. */
136 /* Type describing an ARM Hardware Breakpoint Control register value. */
137 typedef unsigned int arm_hwbp_control_t
;
139 /* Structure used to keep track of hardware break-/watch-points. */
140 struct arm_linux_hw_breakpoint
142 /* Address to break on, or being watched. */
143 unsigned int address
;
144 /* Control register for break-/watch- point. */
145 arm_hwbp_control_t control
;
148 /* Since we cannot dynamically allocate subfields of arch_process_info,
149 assume a maximum number of supported break-/watchpoints. */
153 /* Per-process arch-specific data we want to keep. */
154 struct arch_process_info
156 /* Hardware breakpoints for this process. */
157 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
158 /* Hardware watchpoints for this process. */
159 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
162 /* Per-thread arch-specific data we want to keep. */
165 /* Non-zero if our copy differs from what's recorded in the thread. */
166 char bpts_changed
[MAX_BPTS
];
167 char wpts_changed
[MAX_WPTS
];
168 /* Cached stopped data address. */
169 CORE_ADDR stopped_data_address
;
172 /* These are in <asm/elf.h> in current kernels. */
174 #define HWCAP_IWMMXT 512
175 #define HWCAP_NEON 4096
176 #define HWCAP_VFPv3 8192
177 #define HWCAP_VFPv3D16 16384
179 #ifdef HAVE_SYS_REG_H
183 #define arm_num_regs 26
185 static int arm_regmap
[] = {
186 0, 4, 8, 12, 16, 20, 24, 28,
187 32, 36, 40, 44, 48, 52, 56, 60,
188 -1, -1, -1, -1, -1, -1, -1, -1, -1,
192 /* Forward declarations needed for get_next_pcs ops. */
193 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
197 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
200 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
202 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
204 /* get_next_pcs operations. */
205 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
206 get_next_pcs_read_memory_unsigned_integer
,
207 get_next_pcs_syscall_next_pc
,
208 get_next_pcs_addr_bits_remove
,
209 get_next_pcs_is_thumb
,
210 arm_linux_get_next_pcs_fixup
,
214 arm_target::low_cannot_store_register (int regno
)
216 return (regno
>= arm_num_regs
);
220 arm_target::low_cannot_fetch_register (int regno
)
222 return (regno
>= arm_num_regs
);
226 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
228 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
231 for (int i
= 0; i
< 16; i
++)
232 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
234 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
235 for (int i
= 0; i
< 6; i
++)
236 collect_register (regcache
, arm_num_regs
+ i
+ 16,
237 (char *) buf
+ 16 * 8 + i
* 4);
241 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
243 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
246 for (int i
= 0; i
< 16; i
++)
247 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
249 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
250 for (int i
= 0; i
< 6; i
++)
251 supply_register (regcache
, arm_num_regs
+ i
+ 16,
252 (char *) buf
+ 16 * 8 + i
* 4);
256 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
260 if (is_aarch32_linux_description (regcache
->tdesc
))
264 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
266 if (fp_type
== ARM_FP_TYPE_VFPV3
)
268 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
274 arm_fill_vfpregset_num (regcache
, buf
, num
);
277 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
279 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
281 return UNMAKE_THUMB_ADDR (val
);
285 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
289 if (is_aarch32_linux_description (regcache
->tdesc
))
293 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
295 if (fp_type
== ARM_FP_TYPE_VFPV3
)
297 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
303 arm_store_vfpregset_num (regcache
, buf
, num
);
306 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
308 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
310 return arm_is_thumb_mode ();
313 /* Read memory from the inferior.
314 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
315 read_memory_unsigned_integer. */
317 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
324 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
329 /* Fetch the thread-local storage pointer for libthread_db. */
332 ps_get_thread_area (struct ps_prochandle
*ph
,
333 lwpid_t lwpid
, int idx
, void **base
)
335 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
338 /* IDX is the bias from the thread pointer to the beginning of the
339 thread descriptor. It has to be subtracted due to implementation
340 quirks in libthread_db. */
341 *base
= (void *) ((char *)*base
- idx
);
347 /* Query Hardware Breakpoint information for the target we are attached to
348 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
350 arm_linux_init_hwbp_cap (int pid
)
354 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
357 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
358 if (arm_linux_hwbp_cap
.arch
== 0)
361 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
362 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
363 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
365 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
366 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
367 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
368 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
371 /* How many hardware breakpoints are available? */
373 arm_linux_get_hw_breakpoint_count (void)
375 return arm_linux_hwbp_cap
.bp_count
;
378 /* How many hardware watchpoints are available? */
380 arm_linux_get_hw_watchpoint_count (void)
382 return arm_linux_hwbp_cap
.wp_count
;
385 /* Maximum length of area watched by hardware watchpoint. */
387 arm_linux_get_hw_watchpoint_max_length (void)
389 return arm_linux_hwbp_cap
.max_wp_length
;
392 /* Initialize an ARM hardware break-/watch-point control register value.
393 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
394 type of break-/watch-point; ENABLE indicates whether the point is enabled.
396 static arm_hwbp_control_t
397 arm_hwbp_control_initialize (unsigned byte_address_select
,
398 arm_hwbp_type hwbp_type
,
401 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
402 gdb_assert (hwbp_type
!= arm_hwbp_break
403 || ((byte_address_select
& 0xfU
) != 0));
405 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
408 /* Does the breakpoint control value CONTROL have the enable bit set? */
410 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
412 return control
& 0x1;
415 /* Is the breakpoint control value CONTROL initialized? */
417 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
422 /* Change a breakpoint control word so that it is in the disabled state. */
423 static arm_hwbp_control_t
424 arm_hwbp_control_disable (arm_hwbp_control_t control
)
426 return control
& ~0x1;
429 /* Are two break-/watch-points equal? */
431 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
432 const struct arm_linux_hw_breakpoint
*p2
)
434 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
437 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
440 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
444 case raw_bkpt_type_hw
:
445 return arm_hwbp_break
;
446 case raw_bkpt_type_write_wp
:
447 return arm_hwbp_store
;
448 case raw_bkpt_type_read_wp
:
449 return arm_hwbp_load
;
450 case raw_bkpt_type_access_wp
:
451 return arm_hwbp_access
;
453 gdb_assert_not_reached ("unhandled raw type");
457 /* Initialize the hardware breakpoint structure P for a breakpoint or
458 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
459 Returns -1 if TYPE is unsupported, or -2 if the particular combination
460 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
461 represents a breakpoint and 1 if type represents a watchpoint. */
463 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
464 int len
, struct arm_linux_hw_breakpoint
*p
)
466 arm_hwbp_type hwbp_type
;
469 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
471 if (hwbp_type
== arm_hwbp_break
)
473 /* For breakpoints, the length field encodes the mode. */
476 case 2: /* 16-bit Thumb mode breakpoint */
477 case 3: /* 32-bit Thumb mode breakpoint */
481 case 4: /* 32-bit ARM mode breakpoint */
492 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
493 CORE_ADDR aligned_addr
;
495 /* Can not set watchpoints for zero or negative lengths. */
498 /* The current ptrace interface can only handle watchpoints that are a
500 if ((len
& (len
- 1)) != 0)
503 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
504 range covered by a watchpoint. */
505 aligned_addr
= addr
& ~(max_wp_length
- 1);
506 if (aligned_addr
+ max_wp_length
< addr
+ len
)
509 mask
= (1 << len
) - 1;
512 p
->address
= (unsigned int) addr
;
513 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
515 return hwbp_type
!= arm_hwbp_break
;
518 /* Callback to mark a watch-/breakpoint to be updated in all threads of
519 the current process. */
522 update_registers_callback (thread_info
*thread
, int watch
, int i
)
524 struct lwp_info
*lwp
= get_thread_lwp (thread
);
526 /* The actual update is done later just before resuming the lwp,
527 we just mark that the registers need updating. */
529 lwp
->arch_private
->wpts_changed
[i
] = 1;
531 lwp
->arch_private
->bpts_changed
[i
] = 1;
533 /* If the lwp isn't stopped, force it to momentarily pause, so
534 we can update its breakpoint registers. */
536 linux_stop_lwp (lwp
);
540 arm_supports_z_point_type (char z_type
)
546 case Z_PACKET_WRITE_WP
:
547 case Z_PACKET_READ_WP
:
548 case Z_PACKET_ACCESS_WP
:
551 /* Leave the handling of sw breakpoints with the gdb client. */
556 /* Insert hardware break-/watchpoint. */
558 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
559 int len
, struct raw_breakpoint
*bp
)
561 struct process_info
*proc
= current_process ();
562 struct arm_linux_hw_breakpoint p
, *pts
;
565 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
569 return watch
== -1 ? 1 : -1;
574 count
= arm_linux_get_hw_watchpoint_count ();
575 pts
= proc
->priv
->arch_private
->wpts
;
579 count
= arm_linux_get_hw_breakpoint_count ();
580 pts
= proc
->priv
->arch_private
->bpts
;
583 for (i
= 0; i
< count
; i
++)
584 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
588 /* Only update the threads of the current process. */
589 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
591 update_registers_callback (thread
, watch
, i
);
597 /* We're out of watchpoints. */
601 /* Remove hardware break-/watchpoint. */
603 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
604 int len
, struct raw_breakpoint
*bp
)
606 struct process_info
*proc
= current_process ();
607 struct arm_linux_hw_breakpoint p
, *pts
;
610 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
619 count
= arm_linux_get_hw_watchpoint_count ();
620 pts
= proc
->priv
->arch_private
->wpts
;
624 count
= arm_linux_get_hw_breakpoint_count ();
625 pts
= proc
->priv
->arch_private
->bpts
;
628 for (i
= 0; i
< count
; i
++)
629 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
631 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
633 /* Only update the threads of the current process. */
634 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
636 update_registers_callback (thread
, watch
, i
);
642 /* No watchpoint matched. */
646 /* Return whether current thread is stopped due to a watchpoint. */
648 arm_stopped_by_watchpoint (void)
650 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
653 /* We must be able to set hardware watchpoints. */
654 if (arm_linux_get_hw_watchpoint_count () == 0)
657 /* Retrieve siginfo. */
659 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
663 /* This must be a hardware breakpoint. */
664 if (siginfo
.si_signo
!= SIGTRAP
665 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
668 /* If we are in a positive slot then we're looking at a breakpoint and not
670 if (siginfo
.si_errno
>= 0)
673 /* Cache stopped data address for use by arm_stopped_data_address. */
674 lwp
->arch_private
->stopped_data_address
675 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
680 /* Return data address that triggered watchpoint. Called only if
681 arm_stopped_by_watchpoint returned true. */
683 arm_stopped_data_address (void)
685 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
686 return lwp
->arch_private
->stopped_data_address
;
689 /* Called when a new process is created. */
690 static struct arch_process_info
*
691 arm_new_process (void)
693 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
697 /* Called when a process is being deleted. */
700 arm_delete_process (struct arch_process_info
*info
)
705 /* Called when a new thread is detected. */
707 arm_new_thread (struct lwp_info
*lwp
)
709 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
712 for (i
= 0; i
< MAX_BPTS
; i
++)
713 info
->bpts_changed
[i
] = 1;
714 for (i
= 0; i
< MAX_WPTS
; i
++)
715 info
->wpts_changed
[i
] = 1;
717 lwp
->arch_private
= info
;
720 /* Function to call when a thread is being deleted. */
723 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
729 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
731 struct arch_process_info
*parent_proc_info
;
732 struct arch_process_info
*child_proc_info
;
733 struct lwp_info
*child_lwp
;
734 struct arch_lwp_info
*child_lwp_info
;
737 /* These are allocated by linux_add_process. */
738 gdb_assert (parent
->priv
!= NULL
739 && parent
->priv
->arch_private
!= NULL
);
740 gdb_assert (child
->priv
!= NULL
741 && child
->priv
->arch_private
!= NULL
);
743 parent_proc_info
= parent
->priv
->arch_private
;
744 child_proc_info
= child
->priv
->arch_private
;
746 /* Linux kernel before 2.6.33 commit
747 72f674d203cd230426437cdcf7dd6f681dad8b0d
748 will inherit hardware debug registers from parent
749 on fork/vfork/clone. Newer Linux kernels create such tasks with
750 zeroed debug registers.
752 GDB core assumes the child inherits the watchpoints/hw
753 breakpoints of the parent, and will remove them all from the
754 forked off process. Copy the debug registers mirrors into the
755 new process so that all breakpoints and watchpoints can be
756 removed together. The debug registers mirror will become zeroed
757 in the end before detaching the forked off process, thus making
758 this compatible with older Linux kernels too. */
760 *child_proc_info
= *parent_proc_info
;
762 /* Mark all the hardware breakpoints and watchpoints as changed to
763 make sure that the registers will be updated. */
764 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
765 child_lwp_info
= child_lwp
->arch_private
;
766 for (i
= 0; i
< MAX_BPTS
; i
++)
767 child_lwp_info
->bpts_changed
[i
] = 1;
768 for (i
= 0; i
< MAX_WPTS
; i
++)
769 child_lwp_info
->wpts_changed
[i
] = 1;
772 /* Called when resuming a thread.
773 If the debug regs have changed, update the thread's copies. */
775 arm_prepare_to_resume (struct lwp_info
*lwp
)
777 struct thread_info
*thread
= get_lwp_thread (lwp
);
778 int pid
= lwpid_of (thread
);
779 struct process_info
*proc
= find_process_pid (pid_of (thread
));
780 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
781 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
784 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
785 if (lwp_info
->bpts_changed
[i
])
789 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
790 if (ptrace (PTRACE_SETHBPREGS
, pid
,
791 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
792 &proc_info
->bpts
[i
].address
) < 0)
793 perror_with_name ("Unexpected error setting breakpoint address");
795 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
796 if (ptrace (PTRACE_SETHBPREGS
, pid
,
797 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
798 &proc_info
->bpts
[i
].control
) < 0)
799 perror_with_name ("Unexpected error setting breakpoint");
801 lwp_info
->bpts_changed
[i
] = 0;
804 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
805 if (lwp_info
->wpts_changed
[i
])
809 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
810 if (ptrace (PTRACE_SETHBPREGS
, pid
,
811 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
812 &proc_info
->wpts
[i
].address
) < 0)
813 perror_with_name ("Unexpected error setting watchpoint address");
815 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
816 if (ptrace (PTRACE_SETHBPREGS
, pid
,
817 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
818 &proc_info
->wpts
[i
].control
) < 0)
819 perror_with_name ("Unexpected error setting watchpoint");
821 lwp_info
->wpts_changed
[i
] = 0;
825 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
826 addition, set IS_THUMB depending on whether we will return to ARM
828 See arm-linux.h for stack layout details. */
830 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
834 unsigned long sp_data
;
835 /* Offset of PC register. */
837 CORE_ADDR next_pc
= 0;
840 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
842 collect_register_by_name (regcache
, "sp", &sp
);
843 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
845 pc_offset
= arm_linux_sigreturn_next_pc_offset
846 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
848 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
850 /* Set IS_THUMB according the CPSR saved on the stack. */
851 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
852 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
857 /* When PC is at a syscall instruction, return the PC of the next
858 instruction to be executed. */
860 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
862 CORE_ADDR next_pc
= 0;
863 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
864 int is_thumb
= arm_is_thumb_mode ();
865 ULONGEST svc_number
= 0;
866 struct regcache
*regcache
= self
->regcache
;
870 collect_register (regcache
, 7, &svc_number
);
875 unsigned long this_instr
;
876 unsigned long svc_operand
;
878 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
879 svc_operand
= (0x00ffffff & this_instr
);
881 if (svc_operand
) /* OABI. */
883 svc_number
= svc_operand
- 0x900000;
887 collect_register (regcache
, 7, &svc_number
);
893 /* This is a sigreturn or sigreturn_rt syscall. */
894 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
896 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
898 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
901 /* Addresses for calling Thumb functions have the bit 0 set. */
903 next_pc
= MAKE_THUMB_ADDR (next_pc
);
908 static const struct target_desc
*
909 arm_read_description (void)
911 unsigned long arm_hwcap
= linux_get_hwcap (4);
913 if (arm_hwcap
& HWCAP_IWMMXT
)
914 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
916 if (arm_hwcap
& HWCAP_VFP
)
918 /* Make sure that the kernel supports reading VFP registers. Support was
920 int pid
= lwpid_of (current_thread
);
922 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
923 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
924 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
926 /* NEON implies either no VFP, or VFPv3-D32. We only support
928 if (arm_hwcap
& HWCAP_NEON
)
929 return aarch32_linux_read_description ();
930 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
931 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
933 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
936 /* The default configuration uses legacy FPA registers, probably
938 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
942 arm_target::low_arch_setup ()
944 int tid
= lwpid_of (current_thread
);
948 /* Query hardware watchpoint/breakpoint capabilities. */
949 arm_linux_init_hwbp_cap (tid
);
951 current_process ()->tdesc
= arm_read_description ();
953 iov
.iov_base
= gpregs
;
954 iov
.iov_len
= sizeof (gpregs
);
956 /* Check if PTRACE_GETREGSET works. */
957 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
958 have_ptrace_getregset
= 1;
960 have_ptrace_getregset
= 0;
963 /* Fetch the next possible PCs after the current instruction executes. */
965 static std::vector
<CORE_ADDR
>
966 arm_gdbserver_get_next_pcs (struct regcache
*regcache
)
968 struct arm_get_next_pcs next_pcs_ctx
;
970 arm_get_next_pcs_ctor (&next_pcs_ctx
,
972 /* Byte order is ignored assumed as host. */
978 return arm_get_next_pcs (&next_pcs_ctx
);
981 /* Support for hardware single step. */
984 arm_supports_hardware_single_step (void)
989 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
992 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
994 if (arm_is_thumb_mode ())
995 collect_register_by_name (regcache
, "r7", sysno
);
1001 collect_register_by_name (regcache
, "pc", &pc
);
1003 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1004 *sysno
= UNKNOWN_SYSCALL
;
1007 unsigned long svc_operand
= (0x00ffffff & insn
);
1012 *sysno
= svc_operand
- 0x900000;
1017 collect_register_by_name (regcache
, "r7", sysno
);
1023 /* Register sets without using PTRACE_GETREGSET. */
1025 static struct regset_info arm_regsets
[] = {
1026 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1027 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1028 arm_fill_gregset
, arm_store_gregset
},
1029 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1030 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1031 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1032 arm_fill_vfpregset
, arm_store_vfpregset
},
1036 static struct regsets_info arm_regsets_info
=
1038 arm_regsets
, /* regsets */
1039 0, /* num_regsets */
1040 NULL
, /* disabled_regsets */
1043 static struct usrregs_info arm_usrregs_info
=
1049 static struct regs_info regs_info_arm
=
1051 NULL
, /* regset_bitmap */
1057 arm_target::get_regs_info ()
1059 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1061 if (have_ptrace_getregset
== 1
1062 && (is_aarch32_linux_description (tdesc
)
1063 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1064 return ®s_info_aarch32
;
1066 return ®s_info_arm
;
1069 struct linux_target_ops the_low_target
= {
1070 arm_sw_breakpoint_from_kind
,
1071 arm_gdbserver_get_next_pcs
,
1074 arm_supports_z_point_type
,
1077 arm_stopped_by_watchpoint
,
1078 arm_stopped_data_address
,
1079 NULL
, /* collect_ptrace_register */
1080 NULL
, /* supply_ptrace_register */
1081 NULL
, /* siginfo_fixup */
1087 arm_prepare_to_resume
,
1088 NULL
, /* process_qsupported */
1089 NULL
, /* supports_tracepoints */
1090 NULL
, /* get_thread_area */
1091 NULL
, /* install_fast_tracepoint_jump_pad */
1092 NULL
, /* emit_ops */
1093 NULL
, /* get_min_fast_tracepoint_insn_len */
1094 NULL
, /* supports_range_stepping */
1095 arm_supports_hardware_single_step
,
1096 arm_get_syscall_trapinfo
,
1099 /* The linux target ops object. */
1101 linux_process_target
*the_linux_target
= &the_arm_target
;
1104 initialize_low_arch (void)
1106 initialize_low_arch_aarch32 ();
1107 initialize_regsets_info (&arm_regsets_info
);