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
;
73 void low_arch_setup () override
;
75 bool low_cannot_fetch_register (int regno
) override
;
77 bool low_cannot_store_register (int regno
) override
;
79 bool low_supports_breakpoints () override
;
81 CORE_ADDR
low_get_pc (regcache
*regcache
) override
;
83 void low_set_pc (regcache
*regcache
, CORE_ADDR newpc
) override
;
86 /* The singleton target ops object. */
88 static arm_target the_arm_target
;
91 arm_target::low_supports_breakpoints ()
97 arm_target::low_get_pc (regcache
*regcache
)
99 return linux_get_pc_32bit (regcache
);
103 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
105 linux_set_pc_32bit (regcache
, pc
);
109 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
111 return arm_breakpoint_kind_from_pc (pcptr
);
115 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
117 return arm_breakpoint_kind_from_current_state (pcptr
);
121 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
123 return arm_sw_breakpoint_from_kind (kind
, size
);
126 /* Information describing the hardware breakpoint capabilities. */
130 unsigned char max_wp_length
;
131 unsigned char wp_count
;
132 unsigned char bp_count
;
133 } arm_linux_hwbp_cap
;
135 /* Enum describing the different types of ARM hardware break-/watch-points. */
144 /* Type describing an ARM Hardware Breakpoint Control register value. */
145 typedef unsigned int arm_hwbp_control_t
;
147 /* Structure used to keep track of hardware break-/watch-points. */
148 struct arm_linux_hw_breakpoint
150 /* Address to break on, or being watched. */
151 unsigned int address
;
152 /* Control register for break-/watch- point. */
153 arm_hwbp_control_t control
;
156 /* Since we cannot dynamically allocate subfields of arch_process_info,
157 assume a maximum number of supported break-/watchpoints. */
161 /* Per-process arch-specific data we want to keep. */
162 struct arch_process_info
164 /* Hardware breakpoints for this process. */
165 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
166 /* Hardware watchpoints for this process. */
167 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
170 /* Per-thread arch-specific data we want to keep. */
173 /* Non-zero if our copy differs from what's recorded in the thread. */
174 char bpts_changed
[MAX_BPTS
];
175 char wpts_changed
[MAX_WPTS
];
176 /* Cached stopped data address. */
177 CORE_ADDR stopped_data_address
;
180 /* These are in <asm/elf.h> in current kernels. */
182 #define HWCAP_IWMMXT 512
183 #define HWCAP_NEON 4096
184 #define HWCAP_VFPv3 8192
185 #define HWCAP_VFPv3D16 16384
187 #ifdef HAVE_SYS_REG_H
191 #define arm_num_regs 26
193 static int arm_regmap
[] = {
194 0, 4, 8, 12, 16, 20, 24, 28,
195 32, 36, 40, 44, 48, 52, 56, 60,
196 -1, -1, -1, -1, -1, -1, -1, -1, -1,
200 /* Forward declarations needed for get_next_pcs ops. */
201 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
205 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
208 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
210 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
212 /* get_next_pcs operations. */
213 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
214 get_next_pcs_read_memory_unsigned_integer
,
215 get_next_pcs_syscall_next_pc
,
216 get_next_pcs_addr_bits_remove
,
217 get_next_pcs_is_thumb
,
218 arm_linux_get_next_pcs_fixup
,
222 arm_target::low_cannot_store_register (int regno
)
224 return (regno
>= arm_num_regs
);
228 arm_target::low_cannot_fetch_register (int regno
)
230 return (regno
>= arm_num_regs
);
234 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
236 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
239 for (int i
= 0; i
< 16; i
++)
240 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
242 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
243 for (int i
= 0; i
< 6; i
++)
244 collect_register (regcache
, arm_num_regs
+ i
+ 16,
245 (char *) buf
+ 16 * 8 + i
* 4);
249 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
251 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
254 for (int i
= 0; i
< 16; i
++)
255 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
257 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
258 for (int i
= 0; i
< 6; i
++)
259 supply_register (regcache
, arm_num_regs
+ i
+ 16,
260 (char *) buf
+ 16 * 8 + i
* 4);
264 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
268 if (is_aarch32_linux_description (regcache
->tdesc
))
272 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
274 if (fp_type
== ARM_FP_TYPE_VFPV3
)
276 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
282 arm_fill_vfpregset_num (regcache
, buf
, num
);
285 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
287 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
289 return UNMAKE_THUMB_ADDR (val
);
293 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
297 if (is_aarch32_linux_description (regcache
->tdesc
))
301 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
303 if (fp_type
== ARM_FP_TYPE_VFPV3
)
305 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
311 arm_store_vfpregset_num (regcache
, buf
, num
);
314 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
316 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
318 return arm_is_thumb_mode ();
321 /* Read memory from the inferior.
322 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
323 read_memory_unsigned_integer. */
325 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
332 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
337 /* Fetch the thread-local storage pointer for libthread_db. */
340 ps_get_thread_area (struct ps_prochandle
*ph
,
341 lwpid_t lwpid
, int idx
, void **base
)
343 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
346 /* IDX is the bias from the thread pointer to the beginning of the
347 thread descriptor. It has to be subtracted due to implementation
348 quirks in libthread_db. */
349 *base
= (void *) ((char *)*base
- idx
);
355 /* Query Hardware Breakpoint information for the target we are attached to
356 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
358 arm_linux_init_hwbp_cap (int pid
)
362 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
365 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
366 if (arm_linux_hwbp_cap
.arch
== 0)
369 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
370 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
371 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
373 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
374 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
375 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
376 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
379 /* How many hardware breakpoints are available? */
381 arm_linux_get_hw_breakpoint_count (void)
383 return arm_linux_hwbp_cap
.bp_count
;
386 /* How many hardware watchpoints are available? */
388 arm_linux_get_hw_watchpoint_count (void)
390 return arm_linux_hwbp_cap
.wp_count
;
393 /* Maximum length of area watched by hardware watchpoint. */
395 arm_linux_get_hw_watchpoint_max_length (void)
397 return arm_linux_hwbp_cap
.max_wp_length
;
400 /* Initialize an ARM hardware break-/watch-point control register value.
401 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
402 type of break-/watch-point; ENABLE indicates whether the point is enabled.
404 static arm_hwbp_control_t
405 arm_hwbp_control_initialize (unsigned byte_address_select
,
406 arm_hwbp_type hwbp_type
,
409 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
410 gdb_assert (hwbp_type
!= arm_hwbp_break
411 || ((byte_address_select
& 0xfU
) != 0));
413 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
416 /* Does the breakpoint control value CONTROL have the enable bit set? */
418 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
420 return control
& 0x1;
423 /* Is the breakpoint control value CONTROL initialized? */
425 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
430 /* Change a breakpoint control word so that it is in the disabled state. */
431 static arm_hwbp_control_t
432 arm_hwbp_control_disable (arm_hwbp_control_t control
)
434 return control
& ~0x1;
437 /* Are two break-/watch-points equal? */
439 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
440 const struct arm_linux_hw_breakpoint
*p2
)
442 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
445 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
448 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
452 case raw_bkpt_type_hw
:
453 return arm_hwbp_break
;
454 case raw_bkpt_type_write_wp
:
455 return arm_hwbp_store
;
456 case raw_bkpt_type_read_wp
:
457 return arm_hwbp_load
;
458 case raw_bkpt_type_access_wp
:
459 return arm_hwbp_access
;
461 gdb_assert_not_reached ("unhandled raw type");
465 /* Initialize the hardware breakpoint structure P for a breakpoint or
466 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
467 Returns -1 if TYPE is unsupported, or -2 if the particular combination
468 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
469 represents a breakpoint and 1 if type represents a watchpoint. */
471 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
472 int len
, struct arm_linux_hw_breakpoint
*p
)
474 arm_hwbp_type hwbp_type
;
477 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
479 if (hwbp_type
== arm_hwbp_break
)
481 /* For breakpoints, the length field encodes the mode. */
484 case 2: /* 16-bit Thumb mode breakpoint */
485 case 3: /* 32-bit Thumb mode breakpoint */
489 case 4: /* 32-bit ARM mode breakpoint */
500 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
501 CORE_ADDR aligned_addr
;
503 /* Can not set watchpoints for zero or negative lengths. */
506 /* The current ptrace interface can only handle watchpoints that are a
508 if ((len
& (len
- 1)) != 0)
511 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
512 range covered by a watchpoint. */
513 aligned_addr
= addr
& ~(max_wp_length
- 1);
514 if (aligned_addr
+ max_wp_length
< addr
+ len
)
517 mask
= (1 << len
) - 1;
520 p
->address
= (unsigned int) addr
;
521 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
523 return hwbp_type
!= arm_hwbp_break
;
526 /* Callback to mark a watch-/breakpoint to be updated in all threads of
527 the current process. */
530 update_registers_callback (thread_info
*thread
, int watch
, int i
)
532 struct lwp_info
*lwp
= get_thread_lwp (thread
);
534 /* The actual update is done later just before resuming the lwp,
535 we just mark that the registers need updating. */
537 lwp
->arch_private
->wpts_changed
[i
] = 1;
539 lwp
->arch_private
->bpts_changed
[i
] = 1;
541 /* If the lwp isn't stopped, force it to momentarily pause, so
542 we can update its breakpoint registers. */
544 linux_stop_lwp (lwp
);
548 arm_supports_z_point_type (char z_type
)
554 case Z_PACKET_WRITE_WP
:
555 case Z_PACKET_READ_WP
:
556 case Z_PACKET_ACCESS_WP
:
559 /* Leave the handling of sw breakpoints with the gdb client. */
564 /* Insert hardware break-/watchpoint. */
566 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
567 int len
, struct raw_breakpoint
*bp
)
569 struct process_info
*proc
= current_process ();
570 struct arm_linux_hw_breakpoint p
, *pts
;
573 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
577 return watch
== -1 ? 1 : -1;
582 count
= arm_linux_get_hw_watchpoint_count ();
583 pts
= proc
->priv
->arch_private
->wpts
;
587 count
= arm_linux_get_hw_breakpoint_count ();
588 pts
= proc
->priv
->arch_private
->bpts
;
591 for (i
= 0; i
< count
; i
++)
592 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
596 /* Only update the threads of the current process. */
597 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
599 update_registers_callback (thread
, watch
, i
);
605 /* We're out of watchpoints. */
609 /* Remove hardware break-/watchpoint. */
611 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
612 int len
, struct raw_breakpoint
*bp
)
614 struct process_info
*proc
= current_process ();
615 struct arm_linux_hw_breakpoint p
, *pts
;
618 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
627 count
= arm_linux_get_hw_watchpoint_count ();
628 pts
= proc
->priv
->arch_private
->wpts
;
632 count
= arm_linux_get_hw_breakpoint_count ();
633 pts
= proc
->priv
->arch_private
->bpts
;
636 for (i
= 0; i
< count
; i
++)
637 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
639 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
641 /* Only update the threads of the current process. */
642 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
644 update_registers_callback (thread
, watch
, i
);
650 /* No watchpoint matched. */
654 /* Return whether current thread is stopped due to a watchpoint. */
656 arm_stopped_by_watchpoint (void)
658 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
661 /* We must be able to set hardware watchpoints. */
662 if (arm_linux_get_hw_watchpoint_count () == 0)
665 /* Retrieve siginfo. */
667 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
671 /* This must be a hardware breakpoint. */
672 if (siginfo
.si_signo
!= SIGTRAP
673 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
676 /* If we are in a positive slot then we're looking at a breakpoint and not
678 if (siginfo
.si_errno
>= 0)
681 /* Cache stopped data address for use by arm_stopped_data_address. */
682 lwp
->arch_private
->stopped_data_address
683 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
688 /* Return data address that triggered watchpoint. Called only if
689 arm_stopped_by_watchpoint returned true. */
691 arm_stopped_data_address (void)
693 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
694 return lwp
->arch_private
->stopped_data_address
;
697 /* Called when a new process is created. */
698 static struct arch_process_info
*
699 arm_new_process (void)
701 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
705 /* Called when a process is being deleted. */
708 arm_delete_process (struct arch_process_info
*info
)
713 /* Called when a new thread is detected. */
715 arm_new_thread (struct lwp_info
*lwp
)
717 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
720 for (i
= 0; i
< MAX_BPTS
; i
++)
721 info
->bpts_changed
[i
] = 1;
722 for (i
= 0; i
< MAX_WPTS
; i
++)
723 info
->wpts_changed
[i
] = 1;
725 lwp
->arch_private
= info
;
728 /* Function to call when a thread is being deleted. */
731 arm_delete_thread (struct arch_lwp_info
*arch_lwp
)
737 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
739 struct arch_process_info
*parent_proc_info
;
740 struct arch_process_info
*child_proc_info
;
741 struct lwp_info
*child_lwp
;
742 struct arch_lwp_info
*child_lwp_info
;
745 /* These are allocated by linux_add_process. */
746 gdb_assert (parent
->priv
!= NULL
747 && parent
->priv
->arch_private
!= NULL
);
748 gdb_assert (child
->priv
!= NULL
749 && child
->priv
->arch_private
!= NULL
);
751 parent_proc_info
= parent
->priv
->arch_private
;
752 child_proc_info
= child
->priv
->arch_private
;
754 /* Linux kernel before 2.6.33 commit
755 72f674d203cd230426437cdcf7dd6f681dad8b0d
756 will inherit hardware debug registers from parent
757 on fork/vfork/clone. Newer Linux kernels create such tasks with
758 zeroed debug registers.
760 GDB core assumes the child inherits the watchpoints/hw
761 breakpoints of the parent, and will remove them all from the
762 forked off process. Copy the debug registers mirrors into the
763 new process so that all breakpoints and watchpoints can be
764 removed together. The debug registers mirror will become zeroed
765 in the end before detaching the forked off process, thus making
766 this compatible with older Linux kernels too. */
768 *child_proc_info
= *parent_proc_info
;
770 /* Mark all the hardware breakpoints and watchpoints as changed to
771 make sure that the registers will be updated. */
772 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
773 child_lwp_info
= child_lwp
->arch_private
;
774 for (i
= 0; i
< MAX_BPTS
; i
++)
775 child_lwp_info
->bpts_changed
[i
] = 1;
776 for (i
= 0; i
< MAX_WPTS
; i
++)
777 child_lwp_info
->wpts_changed
[i
] = 1;
780 /* Called when resuming a thread.
781 If the debug regs have changed, update the thread's copies. */
783 arm_prepare_to_resume (struct lwp_info
*lwp
)
785 struct thread_info
*thread
= get_lwp_thread (lwp
);
786 int pid
= lwpid_of (thread
);
787 struct process_info
*proc
= find_process_pid (pid_of (thread
));
788 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
789 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
792 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
793 if (lwp_info
->bpts_changed
[i
])
797 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
798 if (ptrace (PTRACE_SETHBPREGS
, pid
,
799 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
800 &proc_info
->bpts
[i
].address
) < 0)
801 perror_with_name ("Unexpected error setting breakpoint address");
803 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
804 if (ptrace (PTRACE_SETHBPREGS
, pid
,
805 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
806 &proc_info
->bpts
[i
].control
) < 0)
807 perror_with_name ("Unexpected error setting breakpoint");
809 lwp_info
->bpts_changed
[i
] = 0;
812 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
813 if (lwp_info
->wpts_changed
[i
])
817 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
818 if (ptrace (PTRACE_SETHBPREGS
, pid
,
819 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
820 &proc_info
->wpts
[i
].address
) < 0)
821 perror_with_name ("Unexpected error setting watchpoint address");
823 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
824 if (ptrace (PTRACE_SETHBPREGS
, pid
,
825 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
826 &proc_info
->wpts
[i
].control
) < 0)
827 perror_with_name ("Unexpected error setting watchpoint");
829 lwp_info
->wpts_changed
[i
] = 0;
833 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
834 addition, set IS_THUMB depending on whether we will return to ARM
836 See arm-linux.h for stack layout details. */
838 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
842 unsigned long sp_data
;
843 /* Offset of PC register. */
845 CORE_ADDR next_pc
= 0;
848 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
850 collect_register_by_name (regcache
, "sp", &sp
);
851 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
853 pc_offset
= arm_linux_sigreturn_next_pc_offset
854 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
856 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
858 /* Set IS_THUMB according the CPSR saved on the stack. */
859 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
860 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
865 /* When PC is at a syscall instruction, return the PC of the next
866 instruction to be executed. */
868 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
870 CORE_ADDR next_pc
= 0;
871 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
872 int is_thumb
= arm_is_thumb_mode ();
873 ULONGEST svc_number
= 0;
874 struct regcache
*regcache
= self
->regcache
;
878 collect_register (regcache
, 7, &svc_number
);
883 unsigned long this_instr
;
884 unsigned long svc_operand
;
886 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
887 svc_operand
= (0x00ffffff & this_instr
);
889 if (svc_operand
) /* OABI. */
891 svc_number
= svc_operand
- 0x900000;
895 collect_register (regcache
, 7, &svc_number
);
901 /* This is a sigreturn or sigreturn_rt syscall. */
902 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
904 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
906 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
909 /* Addresses for calling Thumb functions have the bit 0 set. */
911 next_pc
= MAKE_THUMB_ADDR (next_pc
);
916 static const struct target_desc
*
917 arm_read_description (void)
919 unsigned long arm_hwcap
= linux_get_hwcap (4);
921 if (arm_hwcap
& HWCAP_IWMMXT
)
922 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
924 if (arm_hwcap
& HWCAP_VFP
)
926 /* Make sure that the kernel supports reading VFP registers. Support was
928 int pid
= lwpid_of (current_thread
);
930 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
931 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
932 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
934 /* NEON implies either no VFP, or VFPv3-D32. We only support
936 if (arm_hwcap
& HWCAP_NEON
)
937 return aarch32_linux_read_description ();
938 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
939 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
941 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
944 /* The default configuration uses legacy FPA registers, probably
946 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
950 arm_target::low_arch_setup ()
952 int tid
= lwpid_of (current_thread
);
956 /* Query hardware watchpoint/breakpoint capabilities. */
957 arm_linux_init_hwbp_cap (tid
);
959 current_process ()->tdesc
= arm_read_description ();
961 iov
.iov_base
= gpregs
;
962 iov
.iov_len
= sizeof (gpregs
);
964 /* Check if PTRACE_GETREGSET works. */
965 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
966 have_ptrace_getregset
= 1;
968 have_ptrace_getregset
= 0;
971 /* Fetch the next possible PCs after the current instruction executes. */
973 static std::vector
<CORE_ADDR
>
974 arm_gdbserver_get_next_pcs (struct regcache
*regcache
)
976 struct arm_get_next_pcs next_pcs_ctx
;
978 arm_get_next_pcs_ctor (&next_pcs_ctx
,
980 /* Byte order is ignored assumed as host. */
986 return arm_get_next_pcs (&next_pcs_ctx
);
989 /* Support for hardware single step. */
992 arm_supports_hardware_single_step (void)
997 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1000 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1002 if (arm_is_thumb_mode ())
1003 collect_register_by_name (regcache
, "r7", sysno
);
1009 collect_register_by_name (regcache
, "pc", &pc
);
1011 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1012 *sysno
= UNKNOWN_SYSCALL
;
1015 unsigned long svc_operand
= (0x00ffffff & insn
);
1020 *sysno
= svc_operand
- 0x900000;
1025 collect_register_by_name (regcache
, "r7", sysno
);
1031 /* Register sets without using PTRACE_GETREGSET. */
1033 static struct regset_info arm_regsets
[] = {
1034 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1035 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1036 arm_fill_gregset
, arm_store_gregset
},
1037 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1038 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1039 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1040 arm_fill_vfpregset
, arm_store_vfpregset
},
1044 static struct regsets_info arm_regsets_info
=
1046 arm_regsets
, /* regsets */
1047 0, /* num_regsets */
1048 NULL
, /* disabled_regsets */
1051 static struct usrregs_info arm_usrregs_info
=
1057 static struct regs_info regs_info_arm
=
1059 NULL
, /* regset_bitmap */
1065 arm_target::get_regs_info ()
1067 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1069 if (have_ptrace_getregset
== 1
1070 && (is_aarch32_linux_description (tdesc
)
1071 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1072 return ®s_info_aarch32
;
1074 return ®s_info_arm
;
1077 struct linux_target_ops the_low_target
= {
1078 arm_gdbserver_get_next_pcs
,
1081 arm_supports_z_point_type
,
1084 arm_stopped_by_watchpoint
,
1085 arm_stopped_data_address
,
1086 NULL
, /* collect_ptrace_register */
1087 NULL
, /* supply_ptrace_register */
1088 NULL
, /* siginfo_fixup */
1094 arm_prepare_to_resume
,
1095 NULL
, /* process_qsupported */
1096 NULL
, /* supports_tracepoints */
1097 NULL
, /* get_thread_area */
1098 NULL
, /* install_fast_tracepoint_jump_pad */
1099 NULL
, /* emit_ops */
1100 NULL
, /* get_min_fast_tracepoint_insn_len */
1101 NULL
, /* supports_range_stepping */
1102 arm_supports_hardware_single_step
,
1103 arm_get_syscall_trapinfo
,
1106 /* The linux target ops object. */
1108 linux_process_target
*the_linux_target
= &the_arm_target
;
1111 initialize_low_arch (void)
1113 initialize_low_arch_aarch32 ();
1114 initialize_regsets_info (&arm_regsets_info
);