1 /* Copyright (C) 1995-2015 Free Software Foundation, Inc.
3 This file is part of GDB.
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "linux-low.h"
21 #include "linux-aarch32-low.h"
23 #include <sys/ptrace.h>
24 /* Don't include elf.h if linux/elf.h got included by gdb_proc_service.h.
25 On Bionic elf.h and linux/elf.h have conflicting definitions. */
30 /* Some older versions of GNU/Linux and Android do not define
31 the following macros. */
33 #define NT_ARM_VFP 0x400
36 /* Collect GP registers from REGCACHE to buffer BUF. */
39 arm_fill_gregset (struct regcache
*regcache
, void *buf
)
42 uint32_t *regs
= (uint32_t *) buf
;
44 for (i
= ARM_A1_REGNUM
; i
<= ARM_PC_REGNUM
; i
++)
45 collect_register (regcache
, i
, ®s
[i
]);
47 collect_register (regcache
, ARM_PS_REGNUM
, ®s
[16]);
50 /* Supply GP registers contents, stored in BUF, to REGCACHE. */
53 arm_store_gregset (struct regcache
*regcache
, const void *buf
)
57 const uint32_t *regs
= (const uint32_t *) buf
;
59 memset (zerobuf
, 0, 8);
60 for (i
= ARM_A1_REGNUM
; i
<= ARM_PC_REGNUM
; i
++)
61 supply_register (regcache
, i
, ®s
[i
]);
63 for (; i
< ARM_PS_REGNUM
; i
++)
64 supply_register (regcache
, i
, zerobuf
);
66 supply_register (regcache
, ARM_PS_REGNUM
, ®s
[16]);
69 /* Collect NUM number of VFP registers from REGCACHE to buffer BUF. */
72 arm_fill_vfpregset_num (struct regcache
*regcache
, void *buf
, int num
)
76 gdb_assert (num
== 16 || num
== 32);
78 base
= find_regno (regcache
->tdesc
, "d0");
79 for (i
= 0; i
< num
; i
++)
80 collect_register (regcache
, base
+ i
, (char *) buf
+ i
* 8);
82 collect_register_by_name (regcache
, "fpscr", (char *) buf
+ 32 * 8);
85 /* Supply NUM number of VFP registers contents, stored in BUF, to
89 arm_store_vfpregset_num (struct regcache
*regcache
, const void *buf
, int num
)
93 gdb_assert (num
== 16 || num
== 32);
95 base
= find_regno (regcache
->tdesc
, "d0");
96 for (i
= 0; i
< num
; i
++)
97 supply_register (regcache
, base
+ i
, (char *) buf
+ i
* 8);
99 supply_register_by_name (regcache
, "fpscr", (char *) buf
+ 32 * 8);
103 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
105 arm_fill_vfpregset_num (regcache
, buf
, 32);
109 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
111 arm_store_vfpregset_num (regcache
, buf
, 32);
114 /* Register sets with using PTRACE_GETREGSET. */
116 static struct regset_info aarch32_regsets
[] = {
117 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_PRSTATUS
, 18 * 4,
119 arm_fill_gregset
, arm_store_gregset
},
120 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_ARM_VFP
, 32 * 8 + 4,
122 arm_fill_vfpregset
, arm_store_vfpregset
},
126 static struct regsets_info aarch32_regsets_info
=
128 aarch32_regsets
, /* regsets */
130 NULL
, /* disabled_regsets */
133 struct regs_info regs_info_aarch32
=
135 NULL
, /* regset_bitmap */
137 &aarch32_regsets_info
140 /* Correct in either endianness. */
141 #define arm_abi_breakpoint 0xef9f0001UL
143 /* For new EABI binaries. We recognize it regardless of which ABI
144 is used for gdbserver, so single threaded debugging should work
145 OK, but for multi-threaded debugging we only insert the current
146 ABI's breakpoint instruction. For now at least. */
147 #define arm_eabi_breakpoint 0xe7f001f0UL
150 static const unsigned long arm_breakpoint
= arm_abi_breakpoint
;
152 static const unsigned long arm_breakpoint
= arm_eabi_breakpoint
;
155 #define arm_breakpoint_len 4
156 static const unsigned short thumb_breakpoint
= 0xde01;
157 #define thumb_breakpoint_len 2
158 static const unsigned short thumb2_breakpoint
[] = { 0xf7f0, 0xa000 };
159 #define thumb2_breakpoint_len 4
161 /* Returns 1 if the current instruction set is thumb, 0 otherwise. */
164 arm_is_thumb_mode (void)
166 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
169 collect_register_by_name (regcache
, "cpsr", &cpsr
);
177 /* Returns 1 if there is a software breakpoint at location. */
180 arm_breakpoint_at (CORE_ADDR where
)
182 if (arm_is_thumb_mode ())
187 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 2);
188 if (insn
== thumb_breakpoint
)
191 if (insn
== thumb2_breakpoint
[0])
193 (*the_target
->read_memory
) (where
+ 2, (unsigned char *) &insn
, 2);
194 if (insn
== thumb2_breakpoint
[1])
203 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 4);
204 if (insn
== arm_abi_breakpoint
)
207 if (insn
== arm_eabi_breakpoint
)
214 /* Enum describing the different kinds of breakpoints. */
215 enum arm_breakpoint_kinds
217 ARM_BP_KIND_THUMB
= 2,
218 ARM_BP_KIND_THUMB2
= 3,
222 /* Implementation of linux_target_ops method "breakpoint_kind_from_pc".
224 Determine the type and size of breakpoint to insert at PCPTR. Uses the
225 program counter value to determine whether a 16-bit or 32-bit breakpoint
226 should be used. It returns the breakpoint's kind, and adjusts the program
227 counter (if necessary) to point to the actual memory location where the
228 breakpoint should be inserted. */
231 arm_breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
233 if (IS_THUMB_ADDR (*pcptr
))
237 *pcptr
= UNMAKE_THUMB_ADDR (*pcptr
);
239 /* Check whether we are replacing a thumb2 32-bit instruction. */
240 if ((*the_target
->read_memory
) (*pcptr
, buf
, 2) == 0)
242 unsigned short inst1
= 0;
244 (*the_target
->read_memory
) (*pcptr
, (gdb_byte
*) &inst1
, 2);
245 if (thumb_insn_size (inst1
) == 4)
246 return ARM_BP_KIND_THUMB2
;
248 return ARM_BP_KIND_THUMB
;
251 return ARM_BP_KIND_ARM
;
254 /* Implementation of the linux_target_ops method "sw_breakpoint_from_kind". */
257 arm_sw_breakpoint_from_kind (int kind
, int *size
)
259 *size
= arm_breakpoint_len
;
260 /* Define an ARM-mode breakpoint; we only set breakpoints in the C
261 library, which is most likely to be ARM. If the kernel supports
262 clone events, we will never insert a breakpoint, so even a Thumb
263 C library will work; so will mixing EABI/non-EABI gdbserver and
267 case ARM_BP_KIND_THUMB
:
268 *size
= thumb_breakpoint_len
;
269 return (gdb_byte
*) &thumb_breakpoint
;
270 case ARM_BP_KIND_THUMB2
:
271 *size
= thumb2_breakpoint_len
;
272 return (gdb_byte
*) &thumb2_breakpoint
;
273 case ARM_BP_KIND_ARM
:
274 *size
= arm_breakpoint_len
;
275 return (const gdb_byte
*) &arm_breakpoint
;
282 /* Implementation of the linux_target_ops method
283 "breakpoint_kind_from_current_state". */
286 arm_breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
288 if (arm_is_thumb_mode ())
290 *pcptr
= MAKE_THUMB_ADDR (*pcptr
);
291 return arm_breakpoint_kind_from_pc (pcptr
);
295 return arm_breakpoint_kind_from_pc (pcptr
);
300 initialize_low_arch_aarch32 (void)
302 init_registers_arm_with_neon ();
304 initialize_regsets_info (&aarch32_regsets_info
);