1 /* GNU/Linux/ARM specific low level interface, for the remote server for GDB.
2 Copyright (C) 1995-2015 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 "linux-aarch32-low.h"
25 /* Don't include elf.h if linux/elf.h got included by gdb_proc_service.h.
26 On Bionic elf.h and linux/elf.h have conflicting definitions. */
30 #include "nat/gdb_ptrace.h"
35 /* Defined in auto-generated files. */
36 void init_registers_arm (void);
37 extern const struct target_desc
*tdesc_arm
;
39 void init_registers_arm_with_iwmmxt (void);
40 extern const struct target_desc
*tdesc_arm_with_iwmmxt
;
42 void init_registers_arm_with_vfpv2 (void);
43 extern const struct target_desc
*tdesc_arm_with_vfpv2
;
45 void init_registers_arm_with_vfpv3 (void);
46 extern const struct target_desc
*tdesc_arm_with_vfpv3
;
48 #ifndef PTRACE_GET_THREAD_AREA
49 #define PTRACE_GET_THREAD_AREA 22
52 #ifndef PTRACE_GETWMMXREGS
53 # define PTRACE_GETWMMXREGS 18
54 # define PTRACE_SETWMMXREGS 19
57 #ifndef PTRACE_GETVFPREGS
58 # define PTRACE_GETVFPREGS 27
59 # define PTRACE_SETVFPREGS 28
62 #ifndef PTRACE_GETHBPREGS
63 #define PTRACE_GETHBPREGS 29
64 #define PTRACE_SETHBPREGS 30
67 /* Information describing the hardware breakpoint capabilities. */
71 unsigned char max_wp_length
;
72 unsigned char wp_count
;
73 unsigned char bp_count
;
76 /* Enum describing the different types of ARM hardware break-/watch-points. */
85 /* Enum describing the different kinds of breakpoints. */
86 enum arm_breakpoint_kinds
88 ARM_BP_KIND_THUMB
= 2,
89 ARM_BP_KIND_THUMB2
= 3,
93 /* Type describing an ARM Hardware Breakpoint Control register value. */
94 typedef unsigned int arm_hwbp_control_t
;
96 /* Structure used to keep track of hardware break-/watch-points. */
97 struct arm_linux_hw_breakpoint
99 /* Address to break on, or being watched. */
100 unsigned int address
;
101 /* Control register for break-/watch- point. */
102 arm_hwbp_control_t control
;
105 /* Since we cannot dynamically allocate subfields of arch_process_info,
106 assume a maximum number of supported break-/watchpoints. */
110 /* Per-process arch-specific data we want to keep. */
111 struct arch_process_info
113 /* Hardware breakpoints for this process. */
114 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
115 /* Hardware watchpoints for this process. */
116 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
119 /* Per-thread arch-specific data we want to keep. */
122 /* Non-zero if our copy differs from what's recorded in the thread. */
123 char bpts_changed
[MAX_BPTS
];
124 char wpts_changed
[MAX_WPTS
];
125 /* Cached stopped data address. */
126 CORE_ADDR stopped_data_address
;
129 /* These are in <asm/elf.h> in current kernels. */
131 #define HWCAP_IWMMXT 512
132 #define HWCAP_NEON 4096
133 #define HWCAP_VFPv3 8192
134 #define HWCAP_VFPv3D16 16384
136 #ifdef HAVE_SYS_REG_H
140 #define arm_num_regs 26
142 static int arm_regmap
[] = {
143 0, 4, 8, 12, 16, 20, 24, 28,
144 32, 36, 40, 44, 48, 52, 56, 60,
145 -1, -1, -1, -1, -1, -1, -1, -1, -1,
150 arm_cannot_store_register (int regno
)
152 return (regno
>= arm_num_regs
);
156 arm_cannot_fetch_register (int regno
)
158 return (regno
>= arm_num_regs
);
162 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
166 if (regcache
->tdesc
!= tdesc_arm_with_iwmmxt
)
169 for (i
= 0; i
< 16; i
++)
170 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
172 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
173 for (i
= 0; i
< 6; i
++)
174 collect_register (regcache
, arm_num_regs
+ i
+ 16,
175 (char *) buf
+ 16 * 8 + i
* 4);
179 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
183 if (regcache
->tdesc
!= tdesc_arm_with_iwmmxt
)
186 for (i
= 0; i
< 16; i
++)
187 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
189 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
190 for (i
= 0; i
< 6; i
++)
191 supply_register (regcache
, arm_num_regs
+ i
+ 16,
192 (char *) buf
+ 16 * 8 + i
* 4);
196 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
200 if (regcache
->tdesc
== tdesc_arm_with_neon
201 || regcache
->tdesc
== tdesc_arm_with_vfpv3
)
203 else if (regcache
->tdesc
== tdesc_arm_with_vfpv2
)
208 arm_fill_vfpregset_num (regcache
, buf
, num
);
212 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
216 if (regcache
->tdesc
== tdesc_arm_with_neon
217 || regcache
->tdesc
== tdesc_arm_with_vfpv3
)
219 else if (regcache
->tdesc
== tdesc_arm_with_vfpv2
)
224 arm_store_vfpregset_num (regcache
, buf
, num
);
227 extern int debug_threads
;
230 arm_get_pc (struct regcache
*regcache
)
233 collect_register_by_name (regcache
, "pc", &pc
);
235 debug_printf ("stop pc is %08lx\n", pc
);
240 arm_set_pc (struct regcache
*regcache
, CORE_ADDR pc
)
242 unsigned long newpc
= pc
;
243 supply_register_by_name (regcache
, "pc", &newpc
);
246 /* Correct in either endianness. */
247 #define arm_abi_breakpoint 0xef9f0001UL
249 /* For new EABI binaries. We recognize it regardless of which ABI
250 is used for gdbserver, so single threaded debugging should work
251 OK, but for multi-threaded debugging we only insert the current
252 ABI's breakpoint instruction. For now at least. */
253 #define arm_eabi_breakpoint 0xe7f001f0UL
256 static const unsigned long arm_breakpoint
= arm_abi_breakpoint
;
258 static const unsigned long arm_breakpoint
= arm_eabi_breakpoint
;
261 #define arm_breakpoint_len 4
262 static const unsigned short thumb_breakpoint
= 0xde01;
263 #define thumb_breakpoint_len 2
264 static const unsigned short thumb2_breakpoint
[] = { 0xf7f0, 0xa000 };
265 #define thumb2_breakpoint_len 4
268 arm_breakpoint_at (CORE_ADDR where
)
270 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
273 collect_register_by_name (regcache
, "cpsr", &cpsr
);
280 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 2);
281 if (insn
== thumb_breakpoint
)
284 if (insn
== thumb2_breakpoint
[0])
286 (*the_target
->read_memory
) (where
+ 2, (unsigned char *) &insn
, 2);
287 if (insn
== thumb2_breakpoint
[1])
296 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 4);
297 if (insn
== arm_abi_breakpoint
)
300 if (insn
== arm_eabi_breakpoint
)
307 /* We only place breakpoints in empty marker functions, and thread locking
308 is outside of the function. So rather than importing software single-step,
309 we can just run until exit. */
311 arm_reinsert_addr (void)
313 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
315 collect_register_by_name (regcache
, "lr", &pc
);
319 /* Fetch the thread-local storage pointer for libthread_db. */
322 ps_get_thread_area (const struct ps_prochandle
*ph
,
323 lwpid_t lwpid
, int idx
, void **base
)
325 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
328 /* IDX is the bias from the thread pointer to the beginning of the
329 thread descriptor. It has to be subtracted due to implementation
330 quirks in libthread_db. */
331 *base
= (void *) ((char *)*base
- idx
);
337 /* Query Hardware Breakpoint information for the target we are attached to
338 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
340 arm_linux_init_hwbp_cap (int pid
)
344 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
347 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
348 if (arm_linux_hwbp_cap
.arch
== 0)
351 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
352 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
353 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
355 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
356 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
357 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
358 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
361 /* How many hardware breakpoints are available? */
363 arm_linux_get_hw_breakpoint_count (void)
365 return arm_linux_hwbp_cap
.bp_count
;
368 /* How many hardware watchpoints are available? */
370 arm_linux_get_hw_watchpoint_count (void)
372 return arm_linux_hwbp_cap
.wp_count
;
375 /* Maximum length of area watched by hardware watchpoint. */
377 arm_linux_get_hw_watchpoint_max_length (void)
379 return arm_linux_hwbp_cap
.max_wp_length
;
382 /* Initialize an ARM hardware break-/watch-point control register value.
383 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
384 type of break-/watch-point; ENABLE indicates whether the point is enabled.
386 static arm_hwbp_control_t
387 arm_hwbp_control_initialize (unsigned byte_address_select
,
388 arm_hwbp_type hwbp_type
,
391 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
392 gdb_assert (hwbp_type
!= arm_hwbp_break
393 || ((byte_address_select
& 0xfU
) != 0));
395 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
398 /* Does the breakpoint control value CONTROL have the enable bit set? */
400 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
402 return control
& 0x1;
405 /* Is the breakpoint control value CONTROL initialized? */
407 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
412 /* Change a breakpoint control word so that it is in the disabled state. */
413 static arm_hwbp_control_t
414 arm_hwbp_control_disable (arm_hwbp_control_t control
)
416 return control
& ~0x1;
419 /* Are two break-/watch-points equal? */
421 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
422 const struct arm_linux_hw_breakpoint
*p2
)
424 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
427 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
430 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
434 case raw_bkpt_type_hw
:
435 return arm_hwbp_break
;
436 case raw_bkpt_type_write_wp
:
437 return arm_hwbp_store
;
438 case raw_bkpt_type_read_wp
:
439 return arm_hwbp_load
;
440 case raw_bkpt_type_access_wp
:
441 return arm_hwbp_access
;
443 gdb_assert_not_reached ("unhandled raw type");
447 /* Initialize the hardware breakpoint structure P for a breakpoint or
448 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
449 Returns -1 if TYPE is unsupported, or -2 if the particular combination
450 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
451 represents a breakpoint and 1 if type represents a watchpoint. */
453 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
454 int len
, struct arm_linux_hw_breakpoint
*p
)
456 arm_hwbp_type hwbp_type
;
459 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
461 if (hwbp_type
== arm_hwbp_break
)
463 /* For breakpoints, the length field encodes the mode. */
466 case 2: /* 16-bit Thumb mode breakpoint */
467 case 3: /* 32-bit Thumb mode breakpoint */
471 case 4: /* 32-bit ARM mode breakpoint */
482 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
483 CORE_ADDR aligned_addr
;
485 /* Can not set watchpoints for zero or negative lengths. */
488 /* The current ptrace interface can only handle watchpoints that are a
490 if ((len
& (len
- 1)) != 0)
493 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
494 range covered by a watchpoint. */
495 aligned_addr
= addr
& ~(max_wp_length
- 1);
496 if (aligned_addr
+ max_wp_length
< addr
+ len
)
499 mask
= (1 << len
) - 1;
502 p
->address
= (unsigned int) addr
;
503 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
505 return hwbp_type
!= arm_hwbp_break
;
508 /* Callback to mark a watch-/breakpoint to be updated in all threads of
509 the current process. */
511 struct update_registers_data
518 update_registers_callback (struct inferior_list_entry
*entry
, void *arg
)
520 struct thread_info
*thread
= (struct thread_info
*) entry
;
521 struct lwp_info
*lwp
= get_thread_lwp (thread
);
522 struct update_registers_data
*data
= (struct update_registers_data
*) arg
;
524 /* Only update the threads of the current process. */
525 if (pid_of (thread
) == pid_of (current_thread
))
527 /* The actual update is done later just before resuming the lwp,
528 we just mark that the registers need updating. */
530 lwp
->arch_private
->wpts_changed
[data
->i
] = 1;
532 lwp
->arch_private
->bpts_changed
[data
->i
] = 1;
534 /* If the lwp isn't stopped, force it to momentarily pause, so
535 we can update its breakpoint registers. */
537 linux_stop_lwp (lwp
);
544 arm_supports_z_point_type (char z_type
)
550 case Z_PACKET_WRITE_WP
:
551 case Z_PACKET_READ_WP
:
552 case Z_PACKET_ACCESS_WP
:
555 /* Leave the handling of sw breakpoints with the gdb client. */
560 /* Insert hardware break-/watchpoint. */
562 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
563 int len
, struct raw_breakpoint
*bp
)
565 struct process_info
*proc
= current_process ();
566 struct arm_linux_hw_breakpoint p
, *pts
;
569 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
573 return watch
== -1 ? 1 : -1;
578 count
= arm_linux_get_hw_watchpoint_count ();
579 pts
= proc
->priv
->arch_private
->wpts
;
583 count
= arm_linux_get_hw_breakpoint_count ();
584 pts
= proc
->priv
->arch_private
->bpts
;
587 for (i
= 0; i
< count
; i
++)
588 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
590 struct update_registers_data data
= { watch
, i
};
592 find_inferior (&all_threads
, update_registers_callback
, &data
);
596 /* We're out of watchpoints. */
600 /* Remove hardware break-/watchpoint. */
602 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
603 int len
, struct 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
);
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_linux_hw_breakpoint_equal (&p
, pts
+ i
))
630 struct update_registers_data data
= { watch
, i
};
631 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
632 find_inferior (&all_threads
, update_registers_callback
, &data
);
636 /* No watchpoint matched. */
640 /* Return whether current thread is stopped due to a watchpoint. */
642 arm_stopped_by_watchpoint (void)
644 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
647 /* We must be able to set hardware watchpoints. */
648 if (arm_linux_get_hw_watchpoint_count () == 0)
651 /* Retrieve siginfo. */
653 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
657 /* This must be a hardware breakpoint. */
658 if (siginfo
.si_signo
!= SIGTRAP
659 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
662 /* If we are in a positive slot then we're looking at a breakpoint and not
664 if (siginfo
.si_errno
>= 0)
667 /* Cache stopped data address for use by arm_stopped_data_address. */
668 lwp
->arch_private
->stopped_data_address
669 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
674 /* Return data address that triggered watchpoint. Called only if
675 arm_stopped_by_watchpoint returned true. */
677 arm_stopped_data_address (void)
679 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
680 return lwp
->arch_private
->stopped_data_address
;
683 /* Called when a new process is created. */
684 static struct arch_process_info
*
685 arm_new_process (void)
687 struct arch_process_info
*info
= XCNEW (struct arch_process_info
);
691 /* Called when a new thread is detected. */
693 arm_new_thread (struct lwp_info
*lwp
)
695 struct arch_lwp_info
*info
= XCNEW (struct arch_lwp_info
);
698 for (i
= 0; i
< MAX_BPTS
; i
++)
699 info
->bpts_changed
[i
] = 1;
700 for (i
= 0; i
< MAX_WPTS
; i
++)
701 info
->wpts_changed
[i
] = 1;
703 lwp
->arch_private
= info
;
707 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
709 struct arch_process_info
*parent_proc_info
;
710 struct arch_process_info
*child_proc_info
;
711 struct lwp_info
*child_lwp
;
712 struct arch_lwp_info
*child_lwp_info
;
715 /* These are allocated by linux_add_process. */
716 gdb_assert (parent
->priv
!= NULL
717 && parent
->priv
->arch_private
!= NULL
);
718 gdb_assert (child
->priv
!= NULL
719 && child
->priv
->arch_private
!= NULL
);
721 parent_proc_info
= parent
->priv
->arch_private
;
722 child_proc_info
= child
->priv
->arch_private
;
724 /* Linux kernel before 2.6.33 commit
725 72f674d203cd230426437cdcf7dd6f681dad8b0d
726 will inherit hardware debug registers from parent
727 on fork/vfork/clone. Newer Linux kernels create such tasks with
728 zeroed debug registers.
730 GDB core assumes the child inherits the watchpoints/hw
731 breakpoints of the parent, and will remove them all from the
732 forked off process. Copy the debug registers mirrors into the
733 new process so that all breakpoints and watchpoints can be
734 removed together. The debug registers mirror will become zeroed
735 in the end before detaching the forked off process, thus making
736 this compatible with older Linux kernels too. */
738 *child_proc_info
= *parent_proc_info
;
740 /* Mark all the hardware breakpoints and watchpoints as changed to
741 make sure that the registers will be updated. */
742 child_lwp
= find_lwp_pid (ptid_of (child
));
743 child_lwp_info
= child_lwp
->arch_private
;
744 for (i
= 0; i
< MAX_BPTS
; i
++)
745 child_lwp_info
->bpts_changed
[i
] = 1;
746 for (i
= 0; i
< MAX_WPTS
; i
++)
747 child_lwp_info
->wpts_changed
[i
] = 1;
750 /* Called when resuming a thread.
751 If the debug regs have changed, update the thread's copies. */
753 arm_prepare_to_resume (struct lwp_info
*lwp
)
755 struct thread_info
*thread
= get_lwp_thread (lwp
);
756 int pid
= lwpid_of (thread
);
757 struct process_info
*proc
= find_process_pid (pid_of (thread
));
758 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
759 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
762 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
763 if (lwp_info
->bpts_changed
[i
])
767 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
768 if (ptrace (PTRACE_SETHBPREGS
, pid
,
769 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
770 &proc_info
->bpts
[i
].address
) < 0)
771 perror_with_name ("Unexpected error setting breakpoint address");
773 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
774 if (ptrace (PTRACE_SETHBPREGS
, pid
,
775 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
776 &proc_info
->bpts
[i
].control
) < 0)
777 perror_with_name ("Unexpected error setting breakpoint");
779 lwp_info
->bpts_changed
[i
] = 0;
782 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
783 if (lwp_info
->wpts_changed
[i
])
787 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
788 if (ptrace (PTRACE_SETHBPREGS
, pid
,
789 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
790 &proc_info
->wpts
[i
].address
) < 0)
791 perror_with_name ("Unexpected error setting watchpoint address");
793 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
794 if (ptrace (PTRACE_SETHBPREGS
, pid
,
795 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
796 &proc_info
->wpts
[i
].control
) < 0)
797 perror_with_name ("Unexpected error setting watchpoint");
799 lwp_info
->wpts_changed
[i
] = 0;
805 arm_get_hwcap (unsigned long *valp
)
807 unsigned char *data
= (unsigned char *) alloca (8);
810 while ((*the_target
->read_auxv
) (offset
, data
, 8) == 8)
812 unsigned int *data_p
= (unsigned int *)data
;
813 if (data_p
[0] == AT_HWCAP
)
826 static const struct target_desc
*
827 arm_read_description (void)
829 int pid
= lwpid_of (current_thread
);
830 unsigned long arm_hwcap
= 0;
832 /* Query hardware watchpoint/breakpoint capabilities. */
833 arm_linux_init_hwbp_cap (pid
);
835 if (arm_get_hwcap (&arm_hwcap
) == 0)
838 if (arm_hwcap
& HWCAP_IWMMXT
)
839 return tdesc_arm_with_iwmmxt
;
841 if (arm_hwcap
& HWCAP_VFP
)
843 const struct target_desc
*result
;
846 /* NEON implies either no VFP, or VFPv3-D32. We only support
848 if (arm_hwcap
& HWCAP_NEON
)
849 result
= tdesc_arm_with_neon
;
850 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
851 result
= tdesc_arm_with_vfpv3
;
853 result
= tdesc_arm_with_vfpv2
;
855 /* Now make sure that the kernel supports reading these
856 registers. Support was added in 2.6.30. */
858 buf
= (char *) xmalloc (32 * 8 + 4);
859 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0
868 /* The default configuration uses legacy FPA registers, probably
874 arm_arch_setup (void)
876 int tid
= lwpid_of (current_thread
);
880 current_process ()->tdesc
= arm_read_description ();
882 iov
.iov_base
= gpregs
;
883 iov
.iov_len
= sizeof (gpregs
);
885 /* Check if PTRACE_GETREGSET works. */
886 if (ptrace (PTRACE_GETREGSET
, tid
, NT_PRSTATUS
, &iov
) == 0)
887 have_ptrace_getregset
= 1;
889 have_ptrace_getregset
= 0;
892 /* Register sets without using PTRACE_GETREGSET. */
894 static struct regset_info arm_regsets
[] = {
895 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0, 18 * 4,
897 arm_fill_gregset
, arm_store_gregset
},
898 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, 16 * 8 + 6 * 4,
900 arm_fill_wmmxregset
, arm_store_wmmxregset
},
901 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, 32 * 8 + 4,
903 arm_fill_vfpregset
, arm_store_vfpregset
},
907 static struct regsets_info arm_regsets_info
=
909 arm_regsets
, /* regsets */
911 NULL
, /* disabled_regsets */
914 static struct usrregs_info arm_usrregs_info
=
920 static struct regs_info regs_info_arm
=
922 NULL
, /* regset_bitmap */
927 static const struct regs_info
*
930 const struct target_desc
*tdesc
= current_process ()->tdesc
;
932 if (have_ptrace_getregset
== 1
933 && (tdesc
== tdesc_arm_with_neon
|| tdesc
== tdesc_arm_with_vfpv3
))
934 return ®s_info_aarch32
;
936 return ®s_info_arm
;
939 /* Implementation of linux_target_ops method "breakpoint_kind_from_pc".
941 Determine the type and size of breakpoint to insert at PCPTR. Uses the
942 program counter value to determine whether a 16-bit or 32-bit breakpoint
943 should be used. It returns the breakpoint's kind, and adjusts the program
944 counter (if necessary) to point to the actual memory location where the
945 breakpoint should be inserted. */
948 arm_breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
950 if (IS_THUMB_ADDR (*pcptr
))
954 *pcptr
= UNMAKE_THUMB_ADDR (*pcptr
);
956 /* Check whether we are replacing a thumb2 32-bit instruction. */
957 if ((*the_target
->read_memory
) (*pcptr
, buf
, 2) == 0)
959 unsigned short inst1
= 0;
961 (*the_target
->read_memory
) (*pcptr
, (gdb_byte
*) &inst1
, 2);
962 if (thumb_insn_size (inst1
) == 4)
963 return ARM_BP_KIND_THUMB2
;
965 return ARM_BP_KIND_THUMB
;
968 return ARM_BP_KIND_ARM
;
971 /* Implementation of the linux_target_ops method "sw_breakpoint_from_kind". */
973 static const gdb_byte
*
974 arm_sw_breakpoint_from_kind (int kind
, int *size
)
976 *size
= arm_breakpoint_len
;
977 /* Define an ARM-mode breakpoint; we only set breakpoints in the C
978 library, which is most likely to be ARM. If the kernel supports
979 clone events, we will never insert a breakpoint, so even a Thumb
980 C library will work; so will mixing EABI/non-EABI gdbserver and
984 case ARM_BP_KIND_THUMB
:
985 *size
= thumb_breakpoint_len
;
986 return (gdb_byte
*) &thumb_breakpoint
;
987 case ARM_BP_KIND_THUMB2
:
988 *size
= thumb2_breakpoint_len
;
989 return (gdb_byte
*) &thumb2_breakpoint
;
990 case ARM_BP_KIND_ARM
:
991 *size
= arm_breakpoint_len
;
992 return (const gdb_byte
*) &arm_breakpoint
;
999 struct linux_target_ops the_low_target
= {
1002 arm_cannot_fetch_register
,
1003 arm_cannot_store_register
,
1004 NULL
, /* fetch_register */
1007 arm_breakpoint_kind_from_pc
,
1008 arm_sw_breakpoint_from_kind
,
1012 arm_supports_z_point_type
,
1015 arm_stopped_by_watchpoint
,
1016 arm_stopped_data_address
,
1017 NULL
, /* collect_ptrace_register */
1018 NULL
, /* supply_ptrace_register */
1019 NULL
, /* siginfo_fixup */
1023 arm_prepare_to_resume
,
1027 initialize_low_arch (void)
1029 /* Initialize the Linux target descriptions. */
1030 init_registers_arm ();
1031 init_registers_arm_with_iwmmxt ();
1032 init_registers_arm_with_vfpv2 ();
1033 init_registers_arm_with_vfpv3 ();
1035 initialize_low_arch_aarch32 ();
1037 initialize_regsets_info (&arm_regsets_info
);