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
;
67 void low_arch_setup () override
;
69 bool low_cannot_fetch_register (int regno
) override
;
71 bool low_cannot_store_register (int regno
) override
;
74 /* The singleton target ops object. */
76 static arm_target the_arm_target
;
78 /* Information describing the hardware breakpoint capabilities. */
82 unsigned char max_wp_length
;
83 unsigned char wp_count
;
84 unsigned char bp_count
;
87 /* Enum describing the different types of ARM hardware break-/watch-points. */
96 /* Type describing an ARM Hardware Breakpoint Control register value. */
97 typedef unsigned int arm_hwbp_control_t
;
99 /* Structure used to keep track of hardware break-/watch-points. */
100 struct arm_linux_hw_breakpoint
102 /* Address to break on, or being watched. */
103 unsigned int address
;
104 /* Control register for break-/watch- point. */
105 arm_hwbp_control_t control
;
108 /* Since we cannot dynamically allocate subfields of arch_process_info,
109 assume a maximum number of supported break-/watchpoints. */
113 /* Per-process arch-specific data we want to keep. */
114 struct arch_process_info
116 /* Hardware breakpoints for this process. */
117 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
118 /* Hardware watchpoints for this process. */
119 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
122 /* Per-thread arch-specific data we want to keep. */
125 /* Non-zero if our copy differs from what's recorded in the thread. */
126 char bpts_changed
[MAX_BPTS
];
127 char wpts_changed
[MAX_WPTS
];
128 /* Cached stopped data address. */
129 CORE_ADDR stopped_data_address
;
132 /* These are in <asm/elf.h> in current kernels. */
134 #define HWCAP_IWMMXT 512
135 #define HWCAP_NEON 4096
136 #define HWCAP_VFPv3 8192
137 #define HWCAP_VFPv3D16 16384
139 #ifdef HAVE_SYS_REG_H
143 #define arm_num_regs 26
145 static int arm_regmap
[] = {
146 0, 4, 8, 12, 16, 20, 24, 28,
147 32, 36, 40, 44, 48, 52, 56, 60,
148 -1, -1, -1, -1, -1, -1, -1, -1, -1,
152 /* Forward declarations needed for get_next_pcs ops. */
153 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
157 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
160 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
162 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
164 /* get_next_pcs operations. */
165 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
166 get_next_pcs_read_memory_unsigned_integer
,
167 get_next_pcs_syscall_next_pc
,
168 get_next_pcs_addr_bits_remove
,
169 get_next_pcs_is_thumb
,
170 arm_linux_get_next_pcs_fixup
,
174 arm_target::low_cannot_store_register (int regno
)
176 return (regno
>= arm_num_regs
);
180 arm_target::low_cannot_fetch_register (int regno
)
182 return (regno
>= arm_num_regs
);
186 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
188 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
191 for (int i
= 0; i
< 16; i
++)
192 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
194 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
195 for (int i
= 0; i
< 6; i
++)
196 collect_register (regcache
, arm_num_regs
+ i
+ 16,
197 (char *) buf
+ 16 * 8 + i
* 4);
201 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
203 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
206 for (int i
= 0; i
< 16; i
++)
207 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
209 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
210 for (int i
= 0; i
< 6; i
++)
211 supply_register (regcache
, arm_num_regs
+ i
+ 16,
212 (char *) buf
+ 16 * 8 + i
* 4);
216 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
220 if (is_aarch32_linux_description (regcache
->tdesc
))
224 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
226 if (fp_type
== ARM_FP_TYPE_VFPV3
)
228 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
234 arm_fill_vfpregset_num (regcache
, buf
, num
);
237 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
239 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
241 return UNMAKE_THUMB_ADDR (val
);
245 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
249 if (is_aarch32_linux_description (regcache
->tdesc
))
253 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
255 if (fp_type
== ARM_FP_TYPE_VFPV3
)
257 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
263 arm_store_vfpregset_num (regcache
, buf
, num
);
266 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
268 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
270 return arm_is_thumb_mode ();
273 /* Read memory from the inferior.
274 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
275 read_memory_unsigned_integer. */
277 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
284 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
289 /* Fetch the thread-local storage pointer for libthread_db. */
292 ps_get_thread_area (struct ps_prochandle
*ph
,
293 lwpid_t lwpid
, int idx
, void **base
)
295 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
298 /* IDX is the bias from the thread pointer to the beginning of the
299 thread descriptor. It has to be subtracted due to implementation
300 quirks in libthread_db. */
301 *base
= (void *) ((char *)*base
- idx
);
307 /* Query Hardware Breakpoint information for the target we are attached to
308 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
310 arm_linux_init_hwbp_cap (int pid
)
314 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
317 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
318 if (arm_linux_hwbp_cap
.arch
== 0)
321 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
322 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
323 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
325 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
326 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
327 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
328 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
331 /* How many hardware breakpoints are available? */
333 arm_linux_get_hw_breakpoint_count (void)
335 return arm_linux_hwbp_cap
.bp_count
;
338 /* How many hardware watchpoints are available? */
340 arm_linux_get_hw_watchpoint_count (void)
342 return arm_linux_hwbp_cap
.wp_count
;
345 /* Maximum length of area watched by hardware watchpoint. */
347 arm_linux_get_hw_watchpoint_max_length (void)
349 return arm_linux_hwbp_cap
.max_wp_length
;
352 /* Initialize an ARM hardware break-/watch-point control register value.
353 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
354 type of break-/watch-point; ENABLE indicates whether the point is enabled.
356 static arm_hwbp_control_t
357 arm_hwbp_control_initialize (unsigned byte_address_select
,
358 arm_hwbp_type hwbp_type
,
361 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
362 gdb_assert (hwbp_type
!= arm_hwbp_break
363 || ((byte_address_select
& 0xfU
) != 0));
365 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
368 /* Does the breakpoint control value CONTROL have the enable bit set? */
370 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
372 return control
& 0x1;
375 /* Is the breakpoint control value CONTROL initialized? */
377 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
382 /* Change a breakpoint control word so that it is in the disabled state. */
383 static arm_hwbp_control_t
384 arm_hwbp_control_disable (arm_hwbp_control_t control
)
386 return control
& ~0x1;
389 /* Are two break-/watch-points equal? */
391 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
392 const struct arm_linux_hw_breakpoint
*p2
)
394 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
397 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
400 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
404 case raw_bkpt_type_hw
:
405 return arm_hwbp_break
;
406 case raw_bkpt_type_write_wp
:
407 return arm_hwbp_store
;
408 case raw_bkpt_type_read_wp
:
409 return arm_hwbp_load
;
410 case raw_bkpt_type_access_wp
:
411 return arm_hwbp_access
;
413 gdb_assert_not_reached ("unhandled raw type");
417 /* Initialize the hardware breakpoint structure P for a breakpoint or
418 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
419 Returns -1 if TYPE is unsupported, or -2 if the particular combination
420 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
421 represents a breakpoint and 1 if type represents a watchpoint. */
423 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
424 int len
, struct arm_linux_hw_breakpoint
*p
)
426 arm_hwbp_type hwbp_type
;
429 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
431 if (hwbp_type
== arm_hwbp_break
)
433 /* For breakpoints, the length field encodes the mode. */
436 case 2: /* 16-bit Thumb mode breakpoint */
437 case 3: /* 32-bit Thumb mode breakpoint */
441 case 4: /* 32-bit ARM mode breakpoint */
452 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
453 CORE_ADDR aligned_addr
;
455 /* Can not set watchpoints for zero or negative lengths. */
458 /* The current ptrace interface can only handle watchpoints that are a
460 if ((len
& (len
- 1)) != 0)
463 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
464 range covered by a watchpoint. */
465 aligned_addr
= addr
& ~(max_wp_length
- 1);
466 if (aligned_addr
+ max_wp_length
< addr
+ len
)
469 mask
= (1 << len
) - 1;
472 p
->address
= (unsigned int) addr
;
473 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
475 return hwbp_type
!= arm_hwbp_break
;
478 /* Callback to mark a watch-/breakpoint to be updated in all threads of
479 the current process. */
482 update_registers_callback (thread_info
*thread
, int watch
, int i
)
484 struct lwp_info
*lwp
= get_thread_lwp (thread
);
486 /* The actual update is done later just before resuming the lwp,
487 we just mark that the registers need updating. */
489 lwp
->arch_private
->wpts_changed
[i
] = 1;
491 lwp
->arch_private
->bpts_changed
[i
] = 1;
493 /* If the lwp isn't stopped, force it to momentarily pause, so
494 we can update its breakpoint registers. */
496 linux_stop_lwp (lwp
);
500 arm_supports_z_point_type (char z_type
)
506 case Z_PACKET_WRITE_WP
:
507 case Z_PACKET_READ_WP
:
508 case Z_PACKET_ACCESS_WP
:
511 /* Leave the handling of sw breakpoints with the gdb client. */
516 /* Insert hardware break-/watchpoint. */
518 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
519 int len
, struct raw_breakpoint
*bp
)
521 struct process_info
*proc
= current_process ();
522 struct arm_linux_hw_breakpoint p
, *pts
;
525 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
529 return watch
== -1 ? 1 : -1;
534 count
= arm_linux_get_hw_watchpoint_count ();
535 pts
= proc
->priv
->arch_private
->wpts
;
539 count
= arm_linux_get_hw_breakpoint_count ();
540 pts
= proc
->priv
->arch_private
->bpts
;
543 for (i
= 0; i
< count
; i
++)
544 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
548 /* Only update the threads of the current process. */
549 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
551 update_registers_callback (thread
, watch
, i
);
557 /* We're out of watchpoints. */
561 /* Remove hardware break-/watchpoint. */
563 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
564 int len
, struct raw_breakpoint
*bp
)
566 struct process_info
*proc
= current_process ();
567 struct arm_linux_hw_breakpoint p
, *pts
;
570 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
579 count
= arm_linux_get_hw_watchpoint_count ();
580 pts
= proc
->priv
->arch_private
->wpts
;
584 count
= arm_linux_get_hw_breakpoint_count ();
585 pts
= proc
->priv
->arch_private
->bpts
;
588 for (i
= 0; i
< count
; i
++)
589 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
591 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
593 /* Only update the threads of the current process. */
594 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
596 update_registers_callback (thread
, watch
, i
);
602 /* No watchpoint matched. */
606 /* Return whether current thread is stopped due to a watchpoint. */
608 arm_stopped_by_watchpoint (void)
610 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
613 /* We must be able to set hardware watchpoints. */
614 if (arm_linux_get_hw_watchpoint_count () == 0)
617 /* Retrieve siginfo. */
619 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
623 /* This must be a hardware breakpoint. */
624 if (siginfo
.si_signo
!= SIGTRAP
625 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
628 /* If we are in a positive slot then we're looking at a breakpoint and not
630 if (siginfo
.si_errno
>= 0)
633 /* Cache stopped data address for use by arm_stopped_data_address. */
634 lwp
->arch_private
->stopped_data_address
635 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
640 /* Return data address that triggered watchpoint. Called only if
641 arm_stopped_by_watchpoint returned true. */
643 arm_stopped_data_address (void)
645 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
646 return lwp
->arch_private
->stopped_data_address
;
649 /* Called when a new process is created. */
650 static struct arch_process_info
*
651 arm_new_process (void)
653 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
657 /* Called when a process is being deleted. */
660 arm_delete_process (struct arch_process_info
*info
)
665 /* Called when a new thread is detected. */
667 arm_new_thread (struct lwp_info
*lwp
)
669 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
672 for (i
= 0; i
< MAX_BPTS
; i
++)
673 info
->bpts_changed
[i
] = 1;
674 for (i
= 0; i
< MAX_WPTS
; i
++)
675 info
->wpts_changed
[i
] = 1;
677 lwp
->arch_private
= info
;
680 /* Function to call when a thread is being deleted. */
683 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
689 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
691 struct arch_process_info
*parent_proc_info
;
692 struct arch_process_info
*child_proc_info
;
693 struct lwp_info
*child_lwp
;
694 struct arch_lwp_info
*child_lwp_info
;
697 /* These are allocated by linux_add_process. */
698 gdb_assert (parent
->priv
!= NULL
699 && parent
->priv
->arch_private
!= NULL
);
700 gdb_assert (child
->priv
!= NULL
701 && child
->priv
->arch_private
!= NULL
);
703 parent_proc_info
= parent
->priv
->arch_private
;
704 child_proc_info
= child
->priv
->arch_private
;
706 /* Linux kernel before 2.6.33 commit
707 72f674d203cd230426437cdcf7dd6f681dad8b0d
708 will inherit hardware debug registers from parent
709 on fork/vfork/clone. Newer Linux kernels create such tasks with
710 zeroed debug registers.
712 GDB core assumes the child inherits the watchpoints/hw
713 breakpoints of the parent, and will remove them all from the
714 forked off process. Copy the debug registers mirrors into the
715 new process so that all breakpoints and watchpoints can be
716 removed together. The debug registers mirror will become zeroed
717 in the end before detaching the forked off process, thus making
718 this compatible with older Linux kernels too. */
720 *child_proc_info
= *parent_proc_info
;
722 /* Mark all the hardware breakpoints and watchpoints as changed to
723 make sure that the registers will be updated. */
724 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
725 child_lwp_info
= child_lwp
->arch_private
;
726 for (i
= 0; i
< MAX_BPTS
; i
++)
727 child_lwp_info
->bpts_changed
[i
] = 1;
728 for (i
= 0; i
< MAX_WPTS
; i
++)
729 child_lwp_info
->wpts_changed
[i
] = 1;
732 /* Called when resuming a thread.
733 If the debug regs have changed, update the thread's copies. */
735 arm_prepare_to_resume (struct lwp_info
*lwp
)
737 struct thread_info
*thread
= get_lwp_thread (lwp
);
738 int pid
= lwpid_of (thread
);
739 struct process_info
*proc
= find_process_pid (pid_of (thread
));
740 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
741 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
744 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
745 if (lwp_info
->bpts_changed
[i
])
749 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
750 if (ptrace (PTRACE_SETHBPREGS
, pid
,
751 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
752 &proc_info
->bpts
[i
].address
) < 0)
753 perror_with_name ("Unexpected error setting breakpoint address");
755 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
756 if (ptrace (PTRACE_SETHBPREGS
, pid
,
757 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
758 &proc_info
->bpts
[i
].control
) < 0)
759 perror_with_name ("Unexpected error setting breakpoint");
761 lwp_info
->bpts_changed
[i
] = 0;
764 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
765 if (lwp_info
->wpts_changed
[i
])
769 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
770 if (ptrace (PTRACE_SETHBPREGS
, pid
,
771 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
772 &proc_info
->wpts
[i
].address
) < 0)
773 perror_with_name ("Unexpected error setting watchpoint address");
775 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
776 if (ptrace (PTRACE_SETHBPREGS
, pid
,
777 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
778 &proc_info
->wpts
[i
].control
) < 0)
779 perror_with_name ("Unexpected error setting watchpoint");
781 lwp_info
->wpts_changed
[i
] = 0;
785 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
786 addition, set IS_THUMB depending on whether we will return to ARM
788 See arm-linux.h for stack layout details. */
790 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
794 unsigned long sp_data
;
795 /* Offset of PC register. */
797 CORE_ADDR next_pc
= 0;
800 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
802 collect_register_by_name (regcache
, "sp", &sp
);
803 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
805 pc_offset
= arm_linux_sigreturn_next_pc_offset
806 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
808 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
810 /* Set IS_THUMB according the CPSR saved on the stack. */
811 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
812 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
817 /* When PC is at a syscall instruction, return the PC of the next
818 instruction to be executed. */
820 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
822 CORE_ADDR next_pc
= 0;
823 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
824 int is_thumb
= arm_is_thumb_mode ();
825 ULONGEST svc_number
= 0;
826 struct regcache
*regcache
= self
->regcache
;
830 collect_register (regcache
, 7, &svc_number
);
835 unsigned long this_instr
;
836 unsigned long svc_operand
;
838 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
839 svc_operand
= (0x00ffffff & this_instr
);
841 if (svc_operand
) /* OABI. */
843 svc_number
= svc_operand
- 0x900000;
847 collect_register (regcache
, 7, &svc_number
);
853 /* This is a sigreturn or sigreturn_rt syscall. */
854 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
856 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
858 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
861 /* Addresses for calling Thumb functions have the bit 0 set. */
863 next_pc
= MAKE_THUMB_ADDR (next_pc
);
868 static const struct target_desc
*
869 arm_read_description (void)
871 unsigned long arm_hwcap
= linux_get_hwcap (4);
873 if (arm_hwcap
& HWCAP_IWMMXT
)
874 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
876 if (arm_hwcap
& HWCAP_VFP
)
878 /* Make sure that the kernel supports reading VFP registers. Support was
880 int pid
= lwpid_of (current_thread
);
882 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
883 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
884 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
886 /* NEON implies either no VFP, or VFPv3-D32. We only support
888 if (arm_hwcap
& HWCAP_NEON
)
889 return aarch32_linux_read_description ();
890 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
891 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
893 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
896 /* The default configuration uses legacy FPA registers, probably
898 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
902 arm_target::low_arch_setup ()
904 int tid
= lwpid_of (current_thread
);
908 /* Query hardware watchpoint/breakpoint capabilities. */
909 arm_linux_init_hwbp_cap (tid
);
911 current_process ()->tdesc
= arm_read_description ();
913 iov
.iov_base
= gpregs
;
914 iov
.iov_len
= sizeof (gpregs
);
916 /* Check if PTRACE_GETREGSET works. */
917 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
918 have_ptrace_getregset
= 1;
920 have_ptrace_getregset
= 0;
923 /* Fetch the next possible PCs after the current instruction executes. */
925 static std::vector
<CORE_ADDR
>
926 arm_gdbserver_get_next_pcs (struct regcache
*regcache
)
928 struct arm_get_next_pcs next_pcs_ctx
;
930 arm_get_next_pcs_ctor (&next_pcs_ctx
,
932 /* Byte order is ignored assumed as host. */
938 return arm_get_next_pcs (&next_pcs_ctx
);
941 /* Support for hardware single step. */
944 arm_supports_hardware_single_step (void)
949 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
952 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
954 if (arm_is_thumb_mode ())
955 collect_register_by_name (regcache
, "r7", sysno
);
961 collect_register_by_name (regcache
, "pc", &pc
);
963 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
964 *sysno
= UNKNOWN_SYSCALL
;
967 unsigned long svc_operand
= (0x00ffffff & insn
);
972 *sysno
= svc_operand
- 0x900000;
977 collect_register_by_name (regcache
, "r7", sysno
);
983 /* Register sets without using PTRACE_GETREGSET. */
985 static struct regset_info arm_regsets
[] = {
986 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
987 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
988 arm_fill_gregset
, arm_store_gregset
},
989 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
990 arm_fill_wmmxregset
, arm_store_wmmxregset
},
991 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
992 arm_fill_vfpregset
, arm_store_vfpregset
},
996 static struct regsets_info arm_regsets_info
=
998 arm_regsets
, /* regsets */
1000 NULL
, /* disabled_regsets */
1003 static struct usrregs_info arm_usrregs_info
=
1009 static struct regs_info regs_info_arm
=
1011 NULL
, /* regset_bitmap */
1017 arm_target::get_regs_info ()
1019 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1021 if (have_ptrace_getregset
== 1
1022 && (is_aarch32_linux_description (tdesc
)
1023 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1024 return ®s_info_aarch32
;
1026 return ®s_info_arm
;
1029 struct linux_target_ops the_low_target
= {
1032 arm_breakpoint_kind_from_pc
,
1033 arm_sw_breakpoint_from_kind
,
1034 arm_gdbserver_get_next_pcs
,
1037 arm_supports_z_point_type
,
1040 arm_stopped_by_watchpoint
,
1041 arm_stopped_data_address
,
1042 NULL
, /* collect_ptrace_register */
1043 NULL
, /* supply_ptrace_register */
1044 NULL
, /* siginfo_fixup */
1050 arm_prepare_to_resume
,
1051 NULL
, /* process_qsupported */
1052 NULL
, /* supports_tracepoints */
1053 NULL
, /* get_thread_area */
1054 NULL
, /* install_fast_tracepoint_jump_pad */
1055 NULL
, /* emit_ops */
1056 NULL
, /* get_min_fast_tracepoint_insn_len */
1057 NULL
, /* supports_range_stepping */
1058 arm_breakpoint_kind_from_current_state
,
1059 arm_supports_hardware_single_step
,
1060 arm_get_syscall_trapinfo
,
1063 /* The linux target ops object. */
1065 linux_process_target
*the_linux_target
= &the_arm_target
;
1068 initialize_low_arch (void)
1070 initialize_low_arch_aarch32 ();
1071 initialize_regsets_info (&arm_regsets_info
);