1 /* GNU/Linux on ARM target support.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "floatformat.h"
30 #include "solib-svr4.h"
33 #include "trad-frame.h"
34 #include "tramp-frame.h"
35 #include "breakpoint.h"
38 #include "arm-linux-tdep.h"
39 #include "linux-tdep.h"
40 #include "glibc-tdep.h"
41 #include "arch-utils.h"
43 #include "gdbthread.h"
46 #include "gdb_string.h"
48 extern int arm_apcs_32
;
50 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
51 is to execute a particular software interrupt, rather than use a
52 particular undefined instruction to provoke a trap. Upon exection
53 of the software interrupt the kernel stops the inferior with a
54 SIGTRAP, and wakes the debugger. */
56 static const char arm_linux_arm_le_breakpoint
[] = { 0x01, 0x00, 0x9f, 0xef };
58 static const char arm_linux_arm_be_breakpoint
[] = { 0xef, 0x9f, 0x00, 0x01 };
60 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
61 the operand of the swi if old-ABI compatibility is disabled. Therefore,
62 use an undefined instruction instead. This is supported as of kernel
63 version 2.5.70 (May 2003), so should be a safe assumption for EABI
66 static const char eabi_linux_arm_le_breakpoint
[] = { 0xf0, 0x01, 0xf0, 0xe7 };
68 static const char eabi_linux_arm_be_breakpoint
[] = { 0xe7, 0xf0, 0x01, 0xf0 };
70 /* All the kernels which support Thumb support using a specific undefined
71 instruction for the Thumb breakpoint. */
73 static const char arm_linux_thumb_be_breakpoint
[] = {0xde, 0x01};
75 static const char arm_linux_thumb_le_breakpoint
[] = {0x01, 0xde};
77 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
78 we must use a length-appropriate breakpoint for 32-bit Thumb
79 instructions. See also thumb_get_next_pc. */
81 static const char arm_linux_thumb2_be_breakpoint
[] = { 0xf7, 0xf0, 0xa0, 0x00 };
83 static const char arm_linux_thumb2_le_breakpoint
[] = { 0xf0, 0xf7, 0x00, 0xa0 };
85 /* Description of the longjmp buffer. The buffer is treated as an array of
86 elements of size ARM_LINUX_JB_ELEMENT_SIZE.
88 The location of saved registers in this buffer (in particular the PC
89 to use after longjmp is called) varies depending on the ABI (in
90 particular the FP model) and also (possibly) the C Library.
92 For glibc, eglibc, and uclibc the following holds: If the FP model is
93 SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
94 buffer. This is also true for the SoftFPA model. However, for the FPA
95 model the PC is at offset 21 in the buffer. */
96 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
97 #define ARM_LINUX_JB_PC_FPA 21
98 #define ARM_LINUX_JB_PC_EABI 9
101 Dynamic Linking on ARM GNU/Linux
102 --------------------------------
104 Note: PLT = procedure linkage table
105 GOT = global offset table
107 As much as possible, ELF dynamic linking defers the resolution of
108 jump/call addresses until the last minute. The technique used is
109 inspired by the i386 ELF design, and is based on the following
112 1) The calling technique should not force a change in the assembly
113 code produced for apps; it MAY cause changes in the way assembly
114 code is produced for position independent code (i.e. shared
117 2) The technique must be such that all executable areas must not be
118 modified; and any modified areas must not be executed.
120 To do this, there are three steps involved in a typical jump:
124 3) using a pointer from the GOT
126 When the executable or library is first loaded, each GOT entry is
127 initialized to point to the code which implements dynamic name
128 resolution and code finding. This is normally a function in the
129 program interpreter (on ARM GNU/Linux this is usually
130 ld-linux.so.2, but it does not have to be). On the first
131 invocation, the function is located and the GOT entry is replaced
132 with the real function address. Subsequent calls go through steps
133 1, 2 and 3 and end up calling the real code.
140 This is typical ARM code using the 26 bit relative branch or branch
141 and link instructions. The target of the instruction
142 (function_call is usually the address of the function to be called.
143 In position independent code, the target of the instruction is
144 actually an entry in the PLT when calling functions in a shared
145 library. Note that this call is identical to a normal function
146 call, only the target differs.
150 The PLT is a synthetic area, created by the linker. It exists in
151 both executables and libraries. It is an array of stubs, one per
152 imported function call. It looks like this:
155 str lr, [sp, #-4]! @push the return address (lr)
156 ldr lr, [pc, #16] @load from 6 words ahead
157 add lr, pc, lr @form an address for GOT[0]
158 ldr pc, [lr, #8]! @jump to the contents of that addr
160 The return address (lr) is pushed on the stack and used for
161 calculations. The load on the second line loads the lr with
162 &GOT[3] - . - 20. The addition on the third leaves:
164 lr = (&GOT[3] - . - 20) + (. + 8)
168 On the fourth line, the pc and lr are both updated, so that:
174 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
175 "tight", but allows us to keep all the PLT entries the same size.
178 ldr ip, [pc, #4] @load offset from gotoff
179 add ip, pc, ip @add the offset to the pc
180 ldr pc, [ip] @jump to that address
181 gotoff: .word GOT[n+3] - .
183 The load on the first line, gets an offset from the fourth word of
184 the PLT entry. The add on the second line makes ip = &GOT[n+3],
185 which contains either a pointer to PLT[0] (the fixup trampoline) or
186 a pointer to the actual code.
190 The GOT contains helper pointers for both code (PLT) fixups and
191 data fixups. The first 3 entries of the GOT are special. The next
192 M entries (where M is the number of entries in the PLT) belong to
193 the PLT fixups. The next D (all remaining) entries belong to
194 various data fixups. The actual size of the GOT is 3 + M + D.
196 The GOT is also a synthetic area, created by the linker. It exists
197 in both executables and libraries. When the GOT is first
198 initialized , all the GOT entries relating to PLT fixups are
199 pointing to code back at PLT[0].
201 The special entries in the GOT are:
203 GOT[0] = linked list pointer used by the dynamic loader
204 GOT[1] = pointer to the reloc table for this module
205 GOT[2] = pointer to the fixup/resolver code
207 The first invocation of function call comes through and uses the
208 fixup/resolver code. On the entry to the fixup/resolver code:
212 stack[0] = return address (lr) of the function call
213 [r0, r1, r2, r3] are still the arguments to the function call
215 This is enough information for the fixup/resolver code to work
216 with. Before the fixup/resolver code returns, it actually calls
217 the requested function and repairs &GOT[n+3]. */
219 /* The constants below were determined by examining the following files
220 in the linux kernel sources:
222 arch/arm/kernel/signal.c
223 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
224 include/asm-arm/unistd.h
225 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
227 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
228 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
230 /* For ARM EABI, the syscall number is not in the SWI instruction
231 (instead it is loaded into r7). We recognize the pattern that
232 glibc uses... alternatively, we could arrange to do this by
233 function name, but they are not always exported. */
234 #define ARM_SET_R7_SIGRETURN 0xe3a07077
235 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
236 #define ARM_EABI_SYSCALL 0xef000000
238 /* OABI syscall restart trampoline, used for EABI executables too
239 whenever OABI support has been enabled in the kernel. */
240 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
241 #define ARM_LDR_PC_SP_12 0xe49df00c
244 arm_linux_sigtramp_cache (struct frame_info
*this_frame
,
245 struct trad_frame_cache
*this_cache
,
246 CORE_ADDR func
, int regs_offset
)
248 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
249 CORE_ADDR base
= sp
+ regs_offset
;
252 for (i
= 0; i
< 16; i
++)
253 trad_frame_set_reg_addr (this_cache
, i
, base
+ i
* 4);
255 trad_frame_set_reg_addr (this_cache
, ARM_PS_REGNUM
, base
+ 16 * 4);
257 /* The VFP or iWMMXt registers may be saved on the stack, but there's
258 no reliable way to restore them (yet). */
260 /* Save a frame ID. */
261 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
264 /* There are a couple of different possible stack layouts that
267 Before version 2.6.18, the kernel used completely independent
268 layouts for non-RT and RT signals. For non-RT signals the stack
269 began directly with a struct sigcontext. For RT signals the stack
270 began with two redundant pointers (to the siginfo and ucontext),
271 and then the siginfo and ucontext.
273 As of version 2.6.18, the non-RT signal frame layout starts with
274 a ucontext and the RT signal frame starts with a siginfo and then
275 a ucontext. Also, the ucontext now has a designated save area
276 for coprocessor registers.
278 For RT signals, it's easy to tell the difference: we look for
279 pinfo, the pointer to the siginfo. If it has the expected
280 value, we have an old layout. If it doesn't, we have the new
283 For non-RT signals, it's a bit harder. We need something in one
284 layout or the other with a recognizable offset and value. We can't
285 use the return trampoline, because ARM usually uses SA_RESTORER,
286 in which case the stack return trampoline is not filled in.
287 We can't use the saved stack pointer, because sigaltstack might
288 be in use. So for now we guess the new layout... */
290 /* There are three words (trap_no, error_code, oldmask) in
291 struct sigcontext before r0. */
292 #define ARM_SIGCONTEXT_R0 0xc
294 /* There are five words (uc_flags, uc_link, and three for uc_stack)
295 in the ucontext_t before the sigcontext. */
296 #define ARM_UCONTEXT_SIGCONTEXT 0x14
298 /* There are three elements in an rt_sigframe before the ucontext:
299 pinfo, puc, and info. The first two are pointers and the third
300 is a struct siginfo, with size 128 bytes. We could follow puc
301 to the ucontext, but it's simpler to skip the whole thing. */
302 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
303 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
305 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
307 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
310 arm_linux_sigreturn_init (const struct tramp_frame
*self
,
311 struct frame_info
*this_frame
,
312 struct trad_frame_cache
*this_cache
,
315 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
316 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
317 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
318 ULONGEST uc_flags
= read_memory_unsigned_integer (sp
, 4, byte_order
);
320 if (uc_flags
== ARM_NEW_SIGFRAME_MAGIC
)
321 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
322 ARM_UCONTEXT_SIGCONTEXT
323 + ARM_SIGCONTEXT_R0
);
325 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
330 arm_linux_rt_sigreturn_init (const struct tramp_frame
*self
,
331 struct frame_info
*this_frame
,
332 struct trad_frame_cache
*this_cache
,
335 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
336 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
337 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
338 ULONGEST pinfo
= read_memory_unsigned_integer (sp
, 4, byte_order
);
340 if (pinfo
== sp
+ ARM_OLD_RT_SIGFRAME_SIGINFO
)
341 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
342 ARM_OLD_RT_SIGFRAME_UCONTEXT
343 + ARM_UCONTEXT_SIGCONTEXT
344 + ARM_SIGCONTEXT_R0
);
346 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
347 ARM_NEW_RT_SIGFRAME_UCONTEXT
348 + ARM_UCONTEXT_SIGCONTEXT
349 + ARM_SIGCONTEXT_R0
);
353 arm_linux_restart_syscall_init (const struct tramp_frame
*self
,
354 struct frame_info
*this_frame
,
355 struct trad_frame_cache
*this_cache
,
358 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
360 trad_frame_set_reg_addr (this_cache
, ARM_PC_REGNUM
, sp
);
361 trad_frame_set_reg_value (this_cache
, ARM_SP_REGNUM
, sp
+ 12);
363 /* Save a frame ID. */
364 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
367 static struct tramp_frame arm_linux_sigreturn_tramp_frame
= {
371 { ARM_LINUX_SIGRETURN_INSTR
, -1 },
372 { TRAMP_SENTINEL_INSN
}
374 arm_linux_sigreturn_init
377 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame
= {
381 { ARM_LINUX_RT_SIGRETURN_INSTR
, -1 },
382 { TRAMP_SENTINEL_INSN
}
384 arm_linux_rt_sigreturn_init
387 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame
= {
391 { ARM_SET_R7_SIGRETURN
, -1 },
392 { ARM_EABI_SYSCALL
, -1 },
393 { TRAMP_SENTINEL_INSN
}
395 arm_linux_sigreturn_init
398 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame
= {
402 { ARM_SET_R7_RT_SIGRETURN
, -1 },
403 { ARM_EABI_SYSCALL
, -1 },
404 { TRAMP_SENTINEL_INSN
}
406 arm_linux_rt_sigreturn_init
409 static struct tramp_frame arm_linux_restart_syscall_tramp_frame
= {
413 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
414 { ARM_LDR_PC_SP_12
, -1 },
415 { TRAMP_SENTINEL_INSN
}
417 arm_linux_restart_syscall_init
420 /* Core file and register set support. */
422 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
425 arm_linux_supply_gregset (const struct regset
*regset
,
426 struct regcache
*regcache
,
427 int regnum
, const void *gregs_buf
, size_t len
)
429 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
430 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
431 const gdb_byte
*gregs
= gregs_buf
;
434 gdb_byte pc_buf
[INT_REGISTER_SIZE
];
436 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
437 if (regnum
== -1 || regnum
== regno
)
438 regcache_raw_supply (regcache
, regno
,
439 gregs
+ INT_REGISTER_SIZE
* regno
);
441 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
444 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
445 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
447 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
448 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
451 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
453 reg_pc
= extract_unsigned_integer (gregs
454 + INT_REGISTER_SIZE
* ARM_PC_REGNUM
,
455 INT_REGISTER_SIZE
, byte_order
);
456 reg_pc
= gdbarch_addr_bits_remove (gdbarch
, reg_pc
);
457 store_unsigned_integer (pc_buf
, INT_REGISTER_SIZE
, byte_order
, reg_pc
);
458 regcache_raw_supply (regcache
, ARM_PC_REGNUM
, pc_buf
);
463 arm_linux_collect_gregset (const struct regset
*regset
,
464 const struct regcache
*regcache
,
465 int regnum
, void *gregs_buf
, size_t len
)
467 gdb_byte
*gregs
= gregs_buf
;
470 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
471 if (regnum
== -1 || regnum
== regno
)
472 regcache_raw_collect (regcache
, regno
,
473 gregs
+ INT_REGISTER_SIZE
* regno
);
475 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
478 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
479 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
481 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
482 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
485 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
486 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
487 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
490 /* Support for register format used by the NWFPE FPA emulator. */
492 #define typeNone 0x00
493 #define typeSingle 0x01
494 #define typeDouble 0x02
495 #define typeExtended 0x03
498 supply_nwfpe_register (struct regcache
*regcache
, int regno
,
499 const gdb_byte
*regs
)
501 const gdb_byte
*reg_data
;
503 gdb_byte buf
[FP_REGISTER_SIZE
];
505 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
506 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
507 memset (buf
, 0, FP_REGISTER_SIZE
);
512 memcpy (buf
, reg_data
, 4);
515 memcpy (buf
, reg_data
+ 4, 4);
516 memcpy (buf
+ 4, reg_data
, 4);
519 /* We want sign and exponent, then least significant bits,
520 then most significant. NWFPE does sign, most, least. */
521 memcpy (buf
, reg_data
, 4);
522 memcpy (buf
+ 4, reg_data
+ 8, 4);
523 memcpy (buf
+ 8, reg_data
+ 4, 4);
529 regcache_raw_supply (regcache
, regno
, buf
);
533 collect_nwfpe_register (const struct regcache
*regcache
, int regno
,
538 gdb_byte buf
[FP_REGISTER_SIZE
];
540 regcache_raw_collect (regcache
, regno
, buf
);
542 /* NOTE drow/2006-06-07: This code uses the tag already in the
543 register buffer. I've preserved that when moving the code
544 from the native file to the target file. But this doesn't
545 always make sense. */
547 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
548 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
553 memcpy (reg_data
, buf
, 4);
556 memcpy (reg_data
, buf
+ 4, 4);
557 memcpy (reg_data
+ 4, buf
, 4);
560 memcpy (reg_data
, buf
, 4);
561 memcpy (reg_data
+ 4, buf
+ 8, 4);
562 memcpy (reg_data
+ 8, buf
+ 4, 4);
570 arm_linux_supply_nwfpe (const struct regset
*regset
,
571 struct regcache
*regcache
,
572 int regnum
, const void *regs_buf
, size_t len
)
574 const gdb_byte
*regs
= regs_buf
;
577 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
578 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
579 regs
+ NWFPE_FPSR_OFFSET
);
581 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
582 if (regnum
== -1 || regnum
== regno
)
583 supply_nwfpe_register (regcache
, regno
, regs
);
587 arm_linux_collect_nwfpe (const struct regset
*regset
,
588 const struct regcache
*regcache
,
589 int regnum
, void *regs_buf
, size_t len
)
591 gdb_byte
*regs
= regs_buf
;
594 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
595 if (regnum
== -1 || regnum
== regno
)
596 collect_nwfpe_register (regcache
, regno
, regs
);
598 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
599 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
,
600 regs
+ INT_REGISTER_SIZE
* ARM_FPS_REGNUM
);
603 /* Return the appropriate register set for the core section identified
604 by SECT_NAME and SECT_SIZE. */
606 static const struct regset
*
607 arm_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
608 const char *sect_name
, size_t sect_size
)
610 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
612 if (strcmp (sect_name
, ".reg") == 0
613 && sect_size
== ARM_LINUX_SIZEOF_GREGSET
)
615 if (tdep
->gregset
== NULL
)
616 tdep
->gregset
= regset_alloc (gdbarch
, arm_linux_supply_gregset
,
617 arm_linux_collect_gregset
);
618 return tdep
->gregset
;
621 if (strcmp (sect_name
, ".reg2") == 0
622 && sect_size
== ARM_LINUX_SIZEOF_NWFPE
)
624 if (tdep
->fpregset
== NULL
)
625 tdep
->fpregset
= regset_alloc (gdbarch
, arm_linux_supply_nwfpe
,
626 arm_linux_collect_nwfpe
);
627 return tdep
->fpregset
;
633 /* Insert a single step breakpoint at the next executed instruction. */
636 arm_linux_software_single_step (struct frame_info
*frame
)
638 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
639 struct address_space
*aspace
= get_frame_address_space (frame
);
640 CORE_ADDR next_pc
= arm_get_next_pc (frame
, get_frame_pc (frame
));
642 /* The Linux kernel offers some user-mode helpers in a high page. We can
643 not read this page (as of 2.6.23), and even if we could then we couldn't
644 set breakpoints in it, and even if we could then the atomic operations
645 would fail when interrupted. They are all called as functions and return
646 to the address in LR, so step to there instead. */
647 if (next_pc
> 0xffff0000)
648 next_pc
= get_frame_register_unsigned (frame
, ARM_LR_REGNUM
);
650 insert_single_step_breakpoint (gdbarch
, aspace
, next_pc
);
655 /* Support for displaced stepping of Linux SVC instructions. */
658 arm_linux_cleanup_svc (struct gdbarch
*gdbarch
,
659 struct regcache
*regs
,
660 struct displaced_step_closure
*dsc
)
662 CORE_ADDR from
= dsc
->insn_addr
;
663 ULONGEST apparent_pc
;
666 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &apparent_pc
);
668 within_scratch
= (apparent_pc
>= dsc
->scratch_base
669 && apparent_pc
< (dsc
->scratch_base
670 + DISPLACED_MODIFIED_INSNS
* 4 + 4));
674 fprintf_unfiltered (gdb_stdlog
, "displaced: PC is apparently %.8lx after "
675 "SVC step ", (unsigned long) apparent_pc
);
677 fprintf_unfiltered (gdb_stdlog
, "(within scratch space)\n");
679 fprintf_unfiltered (gdb_stdlog
, "(outside scratch space)\n");
683 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, from
+ 4, BRANCH_WRITE_PC
);
687 arm_linux_copy_svc (struct gdbarch
*gdbarch
, uint32_t insn
, CORE_ADDR to
,
688 struct regcache
*regs
, struct displaced_step_closure
*dsc
)
690 CORE_ADDR from
= dsc
->insn_addr
;
691 struct frame_info
*frame
;
692 unsigned int svc_number
= displaced_read_reg (regs
, from
, 7);
695 fprintf_unfiltered (gdb_stdlog
, "displaced: copying Linux svc insn %.8lx\n",
696 (unsigned long) insn
);
698 frame
= get_current_frame ();
700 /* Is this a sigreturn or rt_sigreturn syscall? Note: these are only useful
702 if (svc_number
== 119 || svc_number
== 173)
704 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
707 struct symtab_and_line sal
;
710 fprintf_unfiltered (gdb_stdlog
, "displaced: found "
711 "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
712 (unsigned long) get_frame_pc (frame
));
714 return_to
= frame_unwind_caller_pc (frame
);
716 fprintf_unfiltered (gdb_stdlog
, "displaced: unwind pc = %lx. "
717 "Setting momentary breakpoint.\n", (unsigned long) return_to
);
719 gdb_assert (inferior_thread ()->step_resume_breakpoint
== NULL
);
721 sal
= find_pc_line (return_to
, 0);
723 sal
.section
= find_pc_overlay (return_to
);
726 frame
= get_prev_frame (frame
);
730 inferior_thread ()->step_resume_breakpoint
731 = set_momentary_breakpoint (gdbarch
, sal
, get_frame_id (frame
),
734 /* We need to make sure we actually insert the momentary
735 breakpoint set above. */
736 insert_breakpoints ();
738 else if (debug_displaced
)
739 fprintf_unfiltered (gdb_stderr
, "displaced: couldn't find previous "
740 "frame to set momentary breakpoint for "
741 "sigreturn/rt_sigreturn\n");
743 else if (debug_displaced
)
744 fprintf_unfiltered (gdb_stdlog
, "displaced: sigreturn/rt_sigreturn "
745 "SVC call not in signal trampoline frame\n");
748 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
749 location, else nothing.
750 Insn: unmodified svc.
751 Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
752 else leave pc alone. */
754 dsc
->modinsn
[0] = insn
;
756 dsc
->cleanup
= &arm_linux_cleanup_svc
;
757 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
759 dsc
->wrote_to_pc
= 1;
765 /* The following two functions implement single-stepping over calls to Linux
766 kernel helper routines, which perform e.g. atomic operations on architecture
767 variants which don't support them natively.
769 When this function is called, the PC will be pointing at the kernel helper
770 (at an address inaccessible to GDB), and r14 will point to the return
771 address. Displaced stepping always executes code in the copy area:
772 so, make the copy-area instruction branch back to the kernel helper (the
773 "from" address), and make r14 point to the breakpoint in the copy area. In
774 that way, we regain control once the kernel helper returns, and can clean
775 up appropriately (as if we had just returned from the kernel helper as it
776 would have been called from the non-displaced location). */
779 cleanup_kernel_helper_return (struct gdbarch
*gdbarch
,
780 struct regcache
*regs
,
781 struct displaced_step_closure
*dsc
)
783 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, dsc
->tmp
[0], CANNOT_WRITE_PC
);
784 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, dsc
->tmp
[0], BRANCH_WRITE_PC
);
788 arm_catch_kernel_helper_return (struct gdbarch
*gdbarch
, CORE_ADDR from
,
789 CORE_ADDR to
, struct regcache
*regs
,
790 struct displaced_step_closure
*dsc
)
792 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
795 dsc
->insn_addr
= from
;
796 dsc
->cleanup
= &cleanup_kernel_helper_return
;
797 /* Say we wrote to the PC, else cleanup will set PC to the next
798 instruction in the helper, which isn't helpful. */
799 dsc
->wrote_to_pc
= 1;
801 /* Preparation: tmp[0] <- r14
802 r14 <- <scratch space>+4
803 *(<scratch space>+8) <- from
804 Insn: ldr pc, [r14, #4]
805 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
807 dsc
->tmp
[0] = displaced_read_reg (regs
, from
, ARM_LR_REGNUM
);
808 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, (ULONGEST
) to
+ 4,
810 write_memory_unsigned_integer (to
+ 8, 4, byte_order
, from
);
812 dsc
->modinsn
[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
815 /* Linux-specific displaced step instruction copying function. Detects when
816 the program has stepped into a Linux kernel helper routine (which must be
817 handled as a special case), falling back to arm_displaced_step_copy_insn()
820 static struct displaced_step_closure
*
821 arm_linux_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
822 CORE_ADDR from
, CORE_ADDR to
,
823 struct regcache
*regs
)
825 struct displaced_step_closure
*dsc
826 = xmalloc (sizeof (struct displaced_step_closure
));
828 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
829 stop at the return location. */
830 if (from
> 0xffff0000)
833 fprintf_unfiltered (gdb_stdlog
, "displaced: detected kernel helper "
834 "at %.8lx\n", (unsigned long) from
);
836 arm_catch_kernel_helper_return (gdbarch
, from
, to
, regs
, dsc
);
840 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
841 uint32_t insn
= read_memory_unsigned_integer (from
, 4, byte_order
);
844 fprintf_unfiltered (gdb_stdlog
, "displaced: stepping insn %.8lx "
845 "at %.8lx\n", (unsigned long) insn
,
846 (unsigned long) from
);
848 /* Override the default handling of SVC instructions. */
849 dsc
->u
.svc
.copy_svc_os
= arm_linux_copy_svc
;
851 arm_process_displaced_insn (gdbarch
, insn
, from
, to
, regs
, dsc
);
854 arm_displaced_init_closure (gdbarch
, from
, to
, dsc
);
860 arm_linux_init_abi (struct gdbarch_info info
,
861 struct gdbarch
*gdbarch
)
863 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
865 linux_init_abi (info
, gdbarch
);
867 tdep
->lowest_pc
= 0x8000;
868 if (info
.byte_order
== BFD_ENDIAN_BIG
)
870 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
871 tdep
->arm_breakpoint
= eabi_linux_arm_be_breakpoint
;
873 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
874 tdep
->thumb_breakpoint
= arm_linux_thumb_be_breakpoint
;
875 tdep
->thumb2_breakpoint
= arm_linux_thumb2_be_breakpoint
;
879 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
880 tdep
->arm_breakpoint
= eabi_linux_arm_le_breakpoint
;
882 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
883 tdep
->thumb_breakpoint
= arm_linux_thumb_le_breakpoint
;
884 tdep
->thumb2_breakpoint
= arm_linux_thumb2_le_breakpoint
;
886 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
887 tdep
->thumb_breakpoint_size
= sizeof (arm_linux_thumb_le_breakpoint
);
888 tdep
->thumb2_breakpoint_size
= sizeof (arm_linux_thumb2_le_breakpoint
);
890 if (tdep
->fp_model
== ARM_FLOAT_AUTO
)
891 tdep
->fp_model
= ARM_FLOAT_FPA
;
893 switch (tdep
->fp_model
)
896 tdep
->jb_pc
= ARM_LINUX_JB_PC_FPA
;
898 case ARM_FLOAT_SOFT_FPA
:
899 case ARM_FLOAT_SOFT_VFP
:
901 tdep
->jb_pc
= ARM_LINUX_JB_PC_EABI
;
906 _("arm_linux_init_abi: Floating point model not supported"));
909 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
911 set_solib_svr4_fetch_link_map_offsets
912 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
914 /* Single stepping. */
915 set_gdbarch_software_single_step (gdbarch
, arm_linux_software_single_step
);
917 /* Shared library handling. */
918 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
919 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
921 /* Enable TLS support. */
922 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
923 svr4_fetch_objfile_link_map
);
925 tramp_frame_prepend_unwinder (gdbarch
,
926 &arm_linux_sigreturn_tramp_frame
);
927 tramp_frame_prepend_unwinder (gdbarch
,
928 &arm_linux_rt_sigreturn_tramp_frame
);
929 tramp_frame_prepend_unwinder (gdbarch
,
930 &arm_eabi_linux_sigreturn_tramp_frame
);
931 tramp_frame_prepend_unwinder (gdbarch
,
932 &arm_eabi_linux_rt_sigreturn_tramp_frame
);
933 tramp_frame_prepend_unwinder (gdbarch
,
934 &arm_linux_restart_syscall_tramp_frame
);
936 /* Core file support. */
937 set_gdbarch_regset_from_core_section (gdbarch
,
938 arm_linux_regset_from_core_section
);
940 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
942 /* Displaced stepping. */
943 set_gdbarch_displaced_step_copy_insn (gdbarch
,
944 arm_linux_displaced_step_copy_insn
);
945 set_gdbarch_displaced_step_fixup (gdbarch
, arm_displaced_step_fixup
);
946 set_gdbarch_displaced_step_free_closure (gdbarch
,
947 simple_displaced_step_free_closure
);
948 set_gdbarch_displaced_step_location (gdbarch
, displaced_step_at_entry_point
);
951 /* Provide a prototype to silence -Wmissing-prototypes. */
952 extern initialize_file_ftype _initialize_arm_linux_tdep
;
955 _initialize_arm_linux_tdep (void)
957 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,