1 /* Copyright (C) 1995-2016 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 "arch/arm-linux.h"
21 #include "linux-low.h"
22 #include "linux-aarch32-low.h"
24 #include <sys/ptrace.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. */
31 /* Correct in either endianness. */
32 #define arm_abi_breakpoint 0xef9f0001UL
34 /* For new EABI binaries. We recognize it regardless of which ABI
35 is used for gdbserver, so single threaded debugging should work
36 OK, but for multi-threaded debugging we only insert the current
37 ABI's breakpoint instruction. For now at least. */
38 #define arm_eabi_breakpoint 0xe7f001f0UL
40 #if (defined __ARM_EABI__ || defined __aarch64__)
41 static const unsigned long arm_breakpoint
= arm_eabi_breakpoint
;
43 static const unsigned long arm_breakpoint
= arm_abi_breakpoint
;
46 #define arm_breakpoint_len 4
47 static const unsigned short thumb_breakpoint
= 0xde01;
48 #define thumb_breakpoint_len 2
49 static const unsigned short thumb2_breakpoint
[] = { 0xf7f0, 0xa000 };
50 #define thumb2_breakpoint_len 4
52 /* Some older versions of GNU/Linux and Android do not define
53 the following macros. */
55 #define NT_ARM_VFP 0x400
58 /* Collect GP registers from REGCACHE to buffer BUF. */
61 arm_fill_gregset (struct regcache
*regcache
, void *buf
)
64 uint32_t *regs
= (uint32_t *) buf
;
66 for (i
= ARM_A1_REGNUM
; i
<= ARM_PC_REGNUM
; i
++)
67 collect_register (regcache
, i
, ®s
[i
]);
69 collect_register (regcache
, ARM_PS_REGNUM
, ®s
[ARM_CPSR_GREGNUM
]);
72 /* Supply GP registers contents, stored in BUF, to REGCACHE. */
75 arm_store_gregset (struct regcache
*regcache
, const void *buf
)
79 const uint32_t *regs
= (const uint32_t *) buf
;
80 uint32_t cpsr
= regs
[ARM_CPSR_GREGNUM
];
82 memset (zerobuf
, 0, 8);
83 for (i
= ARM_A1_REGNUM
; i
<= ARM_PC_REGNUM
; i
++)
84 supply_register (regcache
, i
, ®s
[i
]);
86 for (; i
< ARM_PS_REGNUM
; i
++)
87 supply_register (regcache
, i
, zerobuf
);
89 /* Clear reserved bits bit 20 to bit 23. */
91 supply_register (regcache
, ARM_PS_REGNUM
, &cpsr
);
94 /* Collect NUM number of VFP registers from REGCACHE to buffer BUF. */
97 arm_fill_vfpregset_num (struct regcache
*regcache
, void *buf
, int num
)
101 gdb_assert (num
== 16 || num
== 32);
103 base
= find_regno (regcache
->tdesc
, "d0");
104 for (i
= 0; i
< num
; i
++)
105 collect_register (regcache
, base
+ i
, (char *) buf
+ i
* 8);
107 collect_register_by_name (regcache
, "fpscr", (char *) buf
+ 32 * 8);
110 /* Supply NUM number of VFP registers contents, stored in BUF, to
114 arm_store_vfpregset_num (struct regcache
*regcache
, const void *buf
, int num
)
118 gdb_assert (num
== 16 || num
== 32);
120 base
= find_regno (regcache
->tdesc
, "d0");
121 for (i
= 0; i
< num
; i
++)
122 supply_register (regcache
, base
+ i
, (char *) buf
+ i
* 8);
124 supply_register_by_name (regcache
, "fpscr", (char *) buf
+ 32 * 8);
128 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
130 arm_fill_vfpregset_num (regcache
, buf
, 32);
134 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
136 arm_store_vfpregset_num (regcache
, buf
, 32);
139 /* Register sets with using PTRACE_GETREGSET. */
141 static struct regset_info aarch32_regsets
[] = {
142 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_PRSTATUS
, 18 * 4,
144 arm_fill_gregset
, arm_store_gregset
},
145 { PTRACE_GETREGSET
, PTRACE_SETREGSET
, NT_ARM_VFP
, 32 * 8 + 4,
147 arm_fill_vfpregset
, arm_store_vfpregset
},
151 static struct regsets_info aarch32_regsets_info
=
153 aarch32_regsets
, /* regsets */
155 NULL
, /* disabled_regsets */
158 struct regs_info regs_info_aarch32
=
160 NULL
, /* regset_bitmap */
162 &aarch32_regsets_info
165 /* Returns 1 if the current instruction set is thumb, 0 otherwise. */
168 arm_is_thumb_mode (void)
170 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
173 collect_register_by_name (regcache
, "cpsr", &cpsr
);
181 /* Returns 1 if there is a software breakpoint at location. */
184 arm_breakpoint_at (CORE_ADDR where
)
186 if (arm_is_thumb_mode ())
191 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 2);
192 if (insn
== thumb_breakpoint
)
195 if (insn
== thumb2_breakpoint
[0])
197 (*the_target
->read_memory
) (where
+ 2, (unsigned char *) &insn
, 2);
198 if (insn
== thumb2_breakpoint
[1])
207 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 4);
208 if (insn
== arm_abi_breakpoint
)
211 if (insn
== arm_eabi_breakpoint
)
218 /* Enum describing the different kinds of breakpoints. */
219 enum arm_breakpoint_kinds
221 ARM_BP_KIND_THUMB
= 2,
222 ARM_BP_KIND_THUMB2
= 3,
226 /* Implementation of linux_target_ops method "breakpoint_kind_from_pc".
228 Determine the type and size of breakpoint to insert at PCPTR. Uses the
229 program counter value to determine whether a 16-bit or 32-bit breakpoint
230 should be used. It returns the breakpoint's kind, and adjusts the program
231 counter (if necessary) to point to the actual memory location where the
232 breakpoint should be inserted. */
235 arm_breakpoint_kind_from_pc (CORE_ADDR
*pcptr
)
237 if (IS_THUMB_ADDR (*pcptr
))
241 *pcptr
= UNMAKE_THUMB_ADDR (*pcptr
);
243 /* Check whether we are replacing a thumb2 32-bit instruction. */
244 if ((*the_target
->read_memory
) (*pcptr
, buf
, 2) == 0)
246 unsigned short inst1
= 0;
248 (*the_target
->read_memory
) (*pcptr
, (gdb_byte
*) &inst1
, 2);
249 if (thumb_insn_size (inst1
) == 4)
250 return ARM_BP_KIND_THUMB2
;
252 return ARM_BP_KIND_THUMB
;
255 return ARM_BP_KIND_ARM
;
258 /* Implementation of the linux_target_ops method "sw_breakpoint_from_kind". */
261 arm_sw_breakpoint_from_kind (int kind
, int *size
)
263 *size
= arm_breakpoint_len
;
264 /* Define an ARM-mode breakpoint; we only set breakpoints in the C
265 library, which is most likely to be ARM. If the kernel supports
266 clone events, we will never insert a breakpoint, so even a Thumb
267 C library will work; so will mixing EABI/non-EABI gdbserver and
271 case ARM_BP_KIND_THUMB
:
272 *size
= thumb_breakpoint_len
;
273 return (gdb_byte
*) &thumb_breakpoint
;
274 case ARM_BP_KIND_THUMB2
:
275 *size
= thumb2_breakpoint_len
;
276 return (gdb_byte
*) &thumb2_breakpoint
;
277 case ARM_BP_KIND_ARM
:
278 *size
= arm_breakpoint_len
;
279 return (const gdb_byte
*) &arm_breakpoint
;
286 /* Implementation of the linux_target_ops method
287 "breakpoint_kind_from_current_state". */
290 arm_breakpoint_kind_from_current_state (CORE_ADDR
*pcptr
)
292 if (arm_is_thumb_mode ())
294 *pcptr
= MAKE_THUMB_ADDR (*pcptr
);
295 return arm_breakpoint_kind_from_pc (pcptr
);
299 return arm_breakpoint_kind_from_pc (pcptr
);
304 initialize_low_arch_aarch32 (void)
306 init_registers_arm_with_neon ();
308 initialize_regsets_info (&aarch32_regsets_info
);