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
;
113 void low_prepare_to_resume (lwp_info
*lwp
) override
;
116 /* The singleton target ops object. */
118 static arm_target the_arm_target
;
121 arm_target::low_supports_breakpoints ()
127 arm_target::low_get_pc (regcache
*regcache
)
129 return linux_get_pc_32bit (regcache
);
133 arm_target::low_set_pc (regcache
*regcache
, CORE_ADDR pc
)
135 linux_set_pc_32bit (regcache
, pc
);
139 arm_target::breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
141 return arm_breakpoint_kind_from_pc (pcptr
);
145 arm_target::breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
147 return arm_breakpoint_kind_from_current_state (pcptr
);
151 arm_target::sw_breakpoint_from_kind (int kind
, int *size
)
153 return arm_sw_breakpoint_from_kind (kind
, size
);
157 arm_target::low_breakpoint_at (CORE_ADDR pc
)
159 return arm_breakpoint_at (pc
);
162 /* Information describing the hardware breakpoint capabilities. */
166 unsigned char max_wp_length
;
167 unsigned char wp_count
;
168 unsigned char bp_count
;
169 } arm_linux_hwbp_cap
;
171 /* Enum describing the different types of ARM hardware break-/watch-points. */
180 /* Type describing an ARM Hardware Breakpoint Control register value. */
181 typedef unsigned int arm_hwbp_control_t
;
183 /* Structure used to keep track of hardware break-/watch-points. */
184 struct arm_linux_hw_breakpoint
186 /* Address to break on, or being watched. */
187 unsigned int address
;
188 /* Control register for break-/watch- point. */
189 arm_hwbp_control_t control
;
192 /* Since we cannot dynamically allocate subfields of arch_process_info,
193 assume a maximum number of supported break-/watchpoints. */
197 /* Per-process arch-specific data we want to keep. */
198 struct arch_process_info
200 /* Hardware breakpoints for this process. */
201 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
202 /* Hardware watchpoints for this process. */
203 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
206 /* Per-thread arch-specific data we want to keep. */
209 /* Non-zero if our copy differs from what's recorded in the thread. */
210 char bpts_changed
[MAX_BPTS
];
211 char wpts_changed
[MAX_WPTS
];
212 /* Cached stopped data address. */
213 CORE_ADDR stopped_data_address
;
216 /* These are in <asm/elf.h> in current kernels. */
218 #define HWCAP_IWMMXT 512
219 #define HWCAP_NEON 4096
220 #define HWCAP_VFPv3 8192
221 #define HWCAP_VFPv3D16 16384
223 #ifdef HAVE_SYS_REG_H
227 #define arm_num_regs 26
229 static int arm_regmap
[] = {
230 0, 4, 8, 12, 16, 20, 24, 28,
231 32, 36, 40, 44, 48, 52, 56, 60,
232 -1, -1, -1, -1, -1, -1, -1, -1, -1,
236 /* Forward declarations needed for get_next_pcs ops. */
237 static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
241 static CORE_ADDR
get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
,
244 static CORE_ADDR
get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
);
246 static int get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
);
248 /* get_next_pcs operations. */
249 static struct arm_get_next_pcs_ops get_next_pcs_ops
= {
250 get_next_pcs_read_memory_unsigned_integer
,
251 get_next_pcs_syscall_next_pc
,
252 get_next_pcs_addr_bits_remove
,
253 get_next_pcs_is_thumb
,
254 arm_linux_get_next_pcs_fixup
,
258 arm_target::low_cannot_store_register (int regno
)
260 return (regno
>= arm_num_regs
);
264 arm_target::low_cannot_fetch_register (int regno
)
266 return (regno
>= arm_num_regs
);
270 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
272 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
275 for (int i
= 0; i
< 16; i
++)
276 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
278 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
279 for (int i
= 0; i
< 6; i
++)
280 collect_register (regcache
, arm_num_regs
+ i
+ 16,
281 (char *) buf
+ 16 * 8 + i
* 4);
285 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
287 if (arm_linux_get_tdesc_fp_type (regcache
->tdesc
) != ARM_FP_TYPE_IWMMXT
)
290 for (int i
= 0; i
< 16; i
++)
291 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
293 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
294 for (int i
= 0; i
< 6; i
++)
295 supply_register (regcache
, arm_num_regs
+ i
+ 16,
296 (char *) buf
+ 16 * 8 + i
* 4);
300 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
304 if (is_aarch32_linux_description (regcache
->tdesc
))
308 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
310 if (fp_type
== ARM_FP_TYPE_VFPV3
)
312 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
318 arm_fill_vfpregset_num (regcache
, buf
, num
);
321 /* Wrapper of UNMAKE_THUMB_ADDR for get_next_pcs. */
323 get_next_pcs_addr_bits_remove (struct arm_get_next_pcs
*self
, CORE_ADDR val
)
325 return UNMAKE_THUMB_ADDR (val
);
329 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
333 if (is_aarch32_linux_description (regcache
->tdesc
))
337 arm_fp_type fp_type
= arm_linux_get_tdesc_fp_type (regcache
->tdesc
);
339 if (fp_type
== ARM_FP_TYPE_VFPV3
)
341 else if (fp_type
== ARM_FP_TYPE_VFPV2
)
347 arm_store_vfpregset_num (regcache
, buf
, num
);
350 /* Wrapper of arm_is_thumb_mode for get_next_pcs. */
352 get_next_pcs_is_thumb (struct arm_get_next_pcs
*self
)
354 return arm_is_thumb_mode ();
357 /* Read memory from the inferior.
358 BYTE_ORDER is ignored and there to keep compatiblity with GDB's
359 read_memory_unsigned_integer. */
361 get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr
,
368 target_read_memory (memaddr
, (unsigned char *) &res
, len
);
373 /* Fetch the thread-local storage pointer for libthread_db. */
376 ps_get_thread_area (struct ps_prochandle
*ph
,
377 lwpid_t lwpid
, int idx
, void **base
)
379 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
382 /* IDX is the bias from the thread pointer to the beginning of the
383 thread descriptor. It has to be subtracted due to implementation
384 quirks in libthread_db. */
385 *base
= (void *) ((char *)*base
- idx
);
391 /* Query Hardware Breakpoint information for the target we are attached to
392 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
394 arm_linux_init_hwbp_cap (int pid
)
398 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
401 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
402 if (arm_linux_hwbp_cap
.arch
== 0)
405 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
406 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
407 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
409 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
410 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
411 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
412 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
415 /* How many hardware breakpoints are available? */
417 arm_linux_get_hw_breakpoint_count (void)
419 return arm_linux_hwbp_cap
.bp_count
;
422 /* How many hardware watchpoints are available? */
424 arm_linux_get_hw_watchpoint_count (void)
426 return arm_linux_hwbp_cap
.wp_count
;
429 /* Maximum length of area watched by hardware watchpoint. */
431 arm_linux_get_hw_watchpoint_max_length (void)
433 return arm_linux_hwbp_cap
.max_wp_length
;
436 /* Initialize an ARM hardware break-/watch-point control register value.
437 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
438 type of break-/watch-point; ENABLE indicates whether the point is enabled.
440 static arm_hwbp_control_t
441 arm_hwbp_control_initialize (unsigned byte_address_select
,
442 arm_hwbp_type hwbp_type
,
445 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
446 gdb_assert (hwbp_type
!= arm_hwbp_break
447 || ((byte_address_select
& 0xfU
) != 0));
449 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
452 /* Does the breakpoint control value CONTROL have the enable bit set? */
454 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
456 return control
& 0x1;
459 /* Is the breakpoint control value CONTROL initialized? */
461 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
466 /* Change a breakpoint control word so that it is in the disabled state. */
467 static arm_hwbp_control_t
468 arm_hwbp_control_disable (arm_hwbp_control_t control
)
470 return control
& ~0x1;
473 /* Are two break-/watch-points equal? */
475 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
476 const struct arm_linux_hw_breakpoint
*p2
)
478 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
481 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
484 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
488 case raw_bkpt_type_hw
:
489 return arm_hwbp_break
;
490 case raw_bkpt_type_write_wp
:
491 return arm_hwbp_store
;
492 case raw_bkpt_type_read_wp
:
493 return arm_hwbp_load
;
494 case raw_bkpt_type_access_wp
:
495 return arm_hwbp_access
;
497 gdb_assert_not_reached ("unhandled raw type");
501 /* Initialize the hardware breakpoint structure P for a breakpoint or
502 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
503 Returns -1 if TYPE is unsupported, or -2 if the particular combination
504 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
505 represents a breakpoint and 1 if type represents a watchpoint. */
507 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
508 int len
, struct arm_linux_hw_breakpoint
*p
)
510 arm_hwbp_type hwbp_type
;
513 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
515 if (hwbp_type
== arm_hwbp_break
)
517 /* For breakpoints, the length field encodes the mode. */
520 case 2: /* 16-bit Thumb mode breakpoint */
521 case 3: /* 32-bit Thumb mode breakpoint */
525 case 4: /* 32-bit ARM mode breakpoint */
536 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
537 CORE_ADDR aligned_addr
;
539 /* Can not set watchpoints for zero or negative lengths. */
542 /* The current ptrace interface can only handle watchpoints that are a
544 if ((len
& (len
- 1)) != 0)
547 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
548 range covered by a watchpoint. */
549 aligned_addr
= addr
& ~(max_wp_length
- 1);
550 if (aligned_addr
+ max_wp_length
< addr
+ len
)
553 mask
= (1 << len
) - 1;
556 p
->address
= (unsigned int) addr
;
557 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
559 return hwbp_type
!= arm_hwbp_break
;
562 /* Callback to mark a watch-/breakpoint to be updated in all threads of
563 the current process. */
566 update_registers_callback (thread_info
*thread
, int watch
, int i
)
568 struct lwp_info
*lwp
= get_thread_lwp (thread
);
570 /* The actual update is done later just before resuming the lwp,
571 we just mark that the registers need updating. */
573 lwp
->arch_private
->wpts_changed
[i
] = 1;
575 lwp
->arch_private
->bpts_changed
[i
] = 1;
577 /* If the lwp isn't stopped, force it to momentarily pause, so
578 we can update its breakpoint registers. */
580 linux_stop_lwp (lwp
);
584 arm_target::supports_z_point_type (char z_type
)
590 case Z_PACKET_WRITE_WP
:
591 case Z_PACKET_READ_WP
:
592 case Z_PACKET_ACCESS_WP
:
595 /* Leave the handling of sw breakpoints with the gdb client. */
600 /* Insert hardware break-/watchpoint. */
602 arm_target::low_insert_point (raw_bkpt_type type
, CORE_ADDR addr
,
603 int len
, raw_breakpoint
*bp
)
605 struct process_info
*proc
= current_process ();
606 struct arm_linux_hw_breakpoint p
, *pts
;
609 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
613 return watch
== -1 ? 1 : -1;
618 count
= arm_linux_get_hw_watchpoint_count ();
619 pts
= proc
->priv
->arch_private
->wpts
;
623 count
= arm_linux_get_hw_breakpoint_count ();
624 pts
= proc
->priv
->arch_private
->bpts
;
627 for (i
= 0; i
< count
; i
++)
628 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
632 /* Only update the threads of the current process. */
633 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
635 update_registers_callback (thread
, watch
, i
);
641 /* We're out of watchpoints. */
645 /* Remove hardware break-/watchpoint. */
647 arm_target::low_remove_point (raw_bkpt_type type
, CORE_ADDR addr
,
648 int len
, raw_breakpoint
*bp
)
650 struct process_info
*proc
= current_process ();
651 struct arm_linux_hw_breakpoint p
, *pts
;
654 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
663 count
= arm_linux_get_hw_watchpoint_count ();
664 pts
= proc
->priv
->arch_private
->wpts
;
668 count
= arm_linux_get_hw_breakpoint_count ();
669 pts
= proc
->priv
->arch_private
->bpts
;
672 for (i
= 0; i
< count
; i
++)
673 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
675 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
677 /* Only update the threads of the current process. */
678 for_each_thread (current_thread
->id
.pid (), [&] (thread_info
*thread
)
680 update_registers_callback (thread
, watch
, i
);
686 /* No watchpoint matched. */
690 /* Return whether current thread is stopped due to a watchpoint. */
692 arm_target::low_stopped_by_watchpoint ()
694 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
697 /* We must be able to set hardware watchpoints. */
698 if (arm_linux_get_hw_watchpoint_count () == 0)
701 /* Retrieve siginfo. */
703 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
707 /* This must be a hardware breakpoint. */
708 if (siginfo
.si_signo
!= SIGTRAP
709 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
712 /* If we are in a positive slot then we're looking at a breakpoint and not
714 if (siginfo
.si_errno
>= 0)
717 /* Cache stopped data address for use by arm_stopped_data_address. */
718 lwp
->arch_private
->stopped_data_address
719 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
724 /* Return data address that triggered watchpoint. Called only if
725 low_stopped_by_watchpoint returned true. */
727 arm_target::low_stopped_data_address ()
729 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
730 return lwp
->arch_private
->stopped_data_address
;
733 /* Called when a new process is created. */
735 arm_target::low_new_process ()
737 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
741 /* Called when a process is being deleted. */
744 arm_target::low_delete_process (arch_process_info
*info
)
749 /* Called when a new thread is detected. */
751 arm_target::low_new_thread (lwp_info
*lwp
)
753 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
756 for (i
= 0; i
< MAX_BPTS
; i
++)
757 info
->bpts_changed
[i
] = 1;
758 for (i
= 0; i
< MAX_WPTS
; i
++)
759 info
->wpts_changed
[i
] = 1;
761 lwp
->arch_private
= info
;
764 /* Function to call when a thread is being deleted. */
767 arm_target::low_delete_thread (arch_lwp_info
*arch_lwp
)
773 arm_target::low_new_fork (process_info
*parent
, process_info
*child
)
775 struct arch_process_info
*parent_proc_info
;
776 struct arch_process_info
*child_proc_info
;
777 struct lwp_info
*child_lwp
;
778 struct arch_lwp_info
*child_lwp_info
;
781 /* These are allocated by linux_add_process. */
782 gdb_assert (parent
->priv
!= NULL
783 && parent
->priv
->arch_private
!= NULL
);
784 gdb_assert (child
->priv
!= NULL
785 && child
->priv
->arch_private
!= NULL
);
787 parent_proc_info
= parent
->priv
->arch_private
;
788 child_proc_info
= child
->priv
->arch_private
;
790 /* Linux kernel before 2.6.33 commit
791 72f674d203cd230426437cdcf7dd6f681dad8b0d
792 will inherit hardware debug registers from parent
793 on fork/vfork/clone. Newer Linux kernels create such tasks with
794 zeroed debug registers.
796 GDB core assumes the child inherits the watchpoints/hw
797 breakpoints of the parent, and will remove them all from the
798 forked off process. Copy the debug registers mirrors into the
799 new process so that all breakpoints and watchpoints can be
800 removed together. The debug registers mirror will become zeroed
801 in the end before detaching the forked off process, thus making
802 this compatible with older Linux kernels too. */
804 *child_proc_info
= *parent_proc_info
;
806 /* Mark all the hardware breakpoints and watchpoints as changed to
807 make sure that the registers will be updated. */
808 child_lwp
= find_lwp_pid (ptid_t (child
->pid
));
809 child_lwp_info
= child_lwp
->arch_private
;
810 for (i
= 0; i
< MAX_BPTS
; i
++)
811 child_lwp_info
->bpts_changed
[i
] = 1;
812 for (i
= 0; i
< MAX_WPTS
; i
++)
813 child_lwp_info
->wpts_changed
[i
] = 1;
816 /* Called when resuming a thread.
817 If the debug regs have changed, update the thread's copies. */
819 arm_target::low_prepare_to_resume (lwp_info
*lwp
)
821 struct thread_info
*thread
= get_lwp_thread (lwp
);
822 int pid
= lwpid_of (thread
);
823 struct process_info
*proc
= find_process_pid (pid_of (thread
));
824 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
825 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
828 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
829 if (lwp_info
->bpts_changed
[i
])
833 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
834 if (ptrace (PTRACE_SETHBPREGS
, pid
,
835 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
836 &proc_info
->bpts
[i
].address
) < 0)
837 perror_with_name ("Unexpected error setting breakpoint address");
839 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
840 if (ptrace (PTRACE_SETHBPREGS
, pid
,
841 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
842 &proc_info
->bpts
[i
].control
) < 0)
843 perror_with_name ("Unexpected error setting breakpoint");
845 lwp_info
->bpts_changed
[i
] = 0;
848 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
849 if (lwp_info
->wpts_changed
[i
])
853 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
854 if (ptrace (PTRACE_SETHBPREGS
, pid
,
855 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
856 &proc_info
->wpts
[i
].address
) < 0)
857 perror_with_name ("Unexpected error setting watchpoint address");
859 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
860 if (ptrace (PTRACE_SETHBPREGS
, pid
,
861 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
862 &proc_info
->wpts
[i
].control
) < 0)
863 perror_with_name ("Unexpected error setting watchpoint");
865 lwp_info
->wpts_changed
[i
] = 0;
869 /* Find the next pc for a sigreturn or rt_sigreturn syscall. In
870 addition, set IS_THUMB depending on whether we will return to ARM
872 See arm-linux.h for stack layout details. */
874 arm_sigreturn_next_pc (struct regcache
*regcache
, int svc_number
,
878 unsigned long sp_data
;
879 /* Offset of PC register. */
881 CORE_ADDR next_pc
= 0;
884 gdb_assert (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
);
886 collect_register_by_name (regcache
, "sp", &sp
);
887 the_target
->read_memory (sp
, (unsigned char *) &sp_data
, 4);
889 pc_offset
= arm_linux_sigreturn_next_pc_offset
890 (sp
, sp_data
, svc_number
, __NR_sigreturn
== svc_number
? 1 : 0);
892 the_target
->read_memory (sp
+ pc_offset
, (unsigned char *) &next_pc
, 4);
894 /* Set IS_THUMB according the CPSR saved on the stack. */
895 the_target
->read_memory (sp
+ pc_offset
+ 4, (unsigned char *) &cpsr
, 4);
896 *is_thumb
= ((cpsr
& CPSR_T
) != 0);
901 /* When PC is at a syscall instruction, return the PC of the next
902 instruction to be executed. */
904 get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
906 CORE_ADDR next_pc
= 0;
907 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
908 int is_thumb
= arm_is_thumb_mode ();
909 ULONGEST svc_number
= 0;
910 struct regcache
*regcache
= self
->regcache
;
914 collect_register (regcache
, 7, &svc_number
);
919 unsigned long this_instr
;
920 unsigned long svc_operand
;
922 target_read_memory (pc
, (unsigned char *) &this_instr
, 4);
923 svc_operand
= (0x00ffffff & this_instr
);
925 if (svc_operand
) /* OABI. */
927 svc_number
= svc_operand
- 0x900000;
931 collect_register (regcache
, 7, &svc_number
);
937 /* This is a sigreturn or sigreturn_rt syscall. */
938 if (svc_number
== __NR_sigreturn
|| svc_number
== __NR_rt_sigreturn
)
940 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
942 next_pc
= arm_sigreturn_next_pc (regcache
, svc_number
, &is_thumb
);
945 /* Addresses for calling Thumb functions have the bit 0 set. */
947 next_pc
= MAKE_THUMB_ADDR (next_pc
);
952 static const struct target_desc
*
953 arm_read_description (void)
955 unsigned long arm_hwcap
= linux_get_hwcap (4);
957 if (arm_hwcap
& HWCAP_IWMMXT
)
958 return arm_linux_read_description (ARM_FP_TYPE_IWMMXT
);
960 if (arm_hwcap
& HWCAP_VFP
)
962 /* Make sure that the kernel supports reading VFP registers. Support was
964 int pid
= lwpid_of (current_thread
);
966 char *buf
= (char *) alloca (ARM_VFP3_REGS_SIZE
);
967 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0 && errno
== EIO
)
968 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
970 /* NEON implies either no VFP, or VFPv3-D32. We only support
972 if (arm_hwcap
& HWCAP_NEON
)
973 return aarch32_linux_read_description ();
974 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
975 return arm_linux_read_description (ARM_FP_TYPE_VFPV3
);
977 return arm_linux_read_description (ARM_FP_TYPE_VFPV2
);
980 /* The default configuration uses legacy FPA registers, probably
982 return arm_linux_read_description (ARM_FP_TYPE_NONE
);
986 arm_target::low_arch_setup ()
988 int tid
= lwpid_of (current_thread
);
992 /* Query hardware watchpoint/breakpoint capabilities. */
993 arm_linux_init_hwbp_cap (tid
);
995 current_process ()->tdesc
= arm_read_description ();
997 iov
.iov_base
= gpregs
;
998 iov
.iov_len
= sizeof (gpregs
);
1000 /* Check if PTRACE_GETREGSET works. */
1001 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
1002 have_ptrace_getregset
= 1;
1004 have_ptrace_getregset
= 0;
1008 arm_target::supports_software_single_step ()
1013 /* Fetch the next possible PCs after the current instruction executes. */
1015 std::vector
<CORE_ADDR
>
1016 arm_target::low_get_next_pcs (regcache
*regcache
)
1018 struct arm_get_next_pcs next_pcs_ctx
;
1020 arm_get_next_pcs_ctor (&next_pcs_ctx
,
1022 /* Byte order is ignored assumed as host. */
1028 return arm_get_next_pcs (&next_pcs_ctx
);
1031 /* Support for hardware single step. */
1034 arm_supports_hardware_single_step (void)
1039 /* Implementation of linux_target_ops method "get_syscall_trapinfo". */
1042 arm_get_syscall_trapinfo (struct regcache
*regcache
, int *sysno
)
1044 if (arm_is_thumb_mode ())
1045 collect_register_by_name (regcache
, "r7", sysno
);
1051 collect_register_by_name (regcache
, "pc", &pc
);
1053 if (the_target
->read_memory (pc
- 4, (unsigned char *) &insn
, 4))
1054 *sysno
= UNKNOWN_SYSCALL
;
1057 unsigned long svc_operand
= (0x00ffffff & insn
);
1062 *sysno
= svc_operand
- 0x900000;
1067 collect_register_by_name (regcache
, "r7", sysno
);
1073 /* Register sets without using PTRACE_GETREGSET. */
1075 static struct regset_info arm_regsets
[] = {
1076 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0,
1077 ARM_CORE_REGS_SIZE
+ ARM_INT_REGISTER_SIZE
, GENERAL_REGS
,
1078 arm_fill_gregset
, arm_store_gregset
},
1079 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, IWMMXT_REGS_SIZE
, EXTENDED_REGS
,
1080 arm_fill_wmmxregset
, arm_store_wmmxregset
},
1081 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, ARM_VFP3_REGS_SIZE
, EXTENDED_REGS
,
1082 arm_fill_vfpregset
, arm_store_vfpregset
},
1086 static struct regsets_info arm_regsets_info
=
1088 arm_regsets
, /* regsets */
1089 0, /* num_regsets */
1090 NULL
, /* disabled_regsets */
1093 static struct usrregs_info arm_usrregs_info
=
1099 static struct regs_info regs_info_arm
=
1101 NULL
, /* regset_bitmap */
1107 arm_target::get_regs_info ()
1109 const struct target_desc
*tdesc
= current_process ()->tdesc
;
1111 if (have_ptrace_getregset
== 1
1112 && (is_aarch32_linux_description (tdesc
)
1113 || arm_linux_get_tdesc_fp_type (tdesc
) == ARM_FP_TYPE_VFPV3
))
1114 return ®s_info_aarch32
;
1116 return ®s_info_arm
;
1119 struct linux_target_ops the_low_target
= {
1120 NULL
, /* emit_ops */
1121 NULL
, /* supports_range_stepping */
1122 arm_supports_hardware_single_step
,
1123 arm_get_syscall_trapinfo
,
1126 /* The linux target ops object. */
1128 linux_process_target
*the_linux_target
= &the_arm_target
;
1131 initialize_low_arch (void)
1133 initialize_low_arch_aarch32 ();
1134 initialize_regsets_info (&arm_regsets_info
);