1 /* GNU/Linux on ARM target support.
3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
4 2009 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 /* Description of the longjmp buffer. */
78 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
79 #define ARM_LINUX_JB_PC 21
82 Dynamic Linking on ARM GNU/Linux
83 --------------------------------
85 Note: PLT = procedure linkage table
86 GOT = global offset table
88 As much as possible, ELF dynamic linking defers the resolution of
89 jump/call addresses until the last minute. The technique used is
90 inspired by the i386 ELF design, and is based on the following
93 1) The calling technique should not force a change in the assembly
94 code produced for apps; it MAY cause changes in the way assembly
95 code is produced for position independent code (i.e. shared
98 2) The technique must be such that all executable areas must not be
99 modified; and any modified areas must not be executed.
101 To do this, there are three steps involved in a typical jump:
105 3) using a pointer from the GOT
107 When the executable or library is first loaded, each GOT entry is
108 initialized to point to the code which implements dynamic name
109 resolution and code finding. This is normally a function in the
110 program interpreter (on ARM GNU/Linux this is usually
111 ld-linux.so.2, but it does not have to be). On the first
112 invocation, the function is located and the GOT entry is replaced
113 with the real function address. Subsequent calls go through steps
114 1, 2 and 3 and end up calling the real code.
121 This is typical ARM code using the 26 bit relative branch or branch
122 and link instructions. The target of the instruction
123 (function_call is usually the address of the function to be called.
124 In position independent code, the target of the instruction is
125 actually an entry in the PLT when calling functions in a shared
126 library. Note that this call is identical to a normal function
127 call, only the target differs.
131 The PLT is a synthetic area, created by the linker. It exists in
132 both executables and libraries. It is an array of stubs, one per
133 imported function call. It looks like this:
136 str lr, [sp, #-4]! @push the return address (lr)
137 ldr lr, [pc, #16] @load from 6 words ahead
138 add lr, pc, lr @form an address for GOT[0]
139 ldr pc, [lr, #8]! @jump to the contents of that addr
141 The return address (lr) is pushed on the stack and used for
142 calculations. The load on the second line loads the lr with
143 &GOT[3] - . - 20. The addition on the third leaves:
145 lr = (&GOT[3] - . - 20) + (. + 8)
149 On the fourth line, the pc and lr are both updated, so that:
155 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
156 "tight", but allows us to keep all the PLT entries the same size.
159 ldr ip, [pc, #4] @load offset from gotoff
160 add ip, pc, ip @add the offset to the pc
161 ldr pc, [ip] @jump to that address
162 gotoff: .word GOT[n+3] - .
164 The load on the first line, gets an offset from the fourth word of
165 the PLT entry. The add on the second line makes ip = &GOT[n+3],
166 which contains either a pointer to PLT[0] (the fixup trampoline) or
167 a pointer to the actual code.
171 The GOT contains helper pointers for both code (PLT) fixups and
172 data fixups. The first 3 entries of the GOT are special. The next
173 M entries (where M is the number of entries in the PLT) belong to
174 the PLT fixups. The next D (all remaining) entries belong to
175 various data fixups. The actual size of the GOT is 3 + M + D.
177 The GOT is also a synthetic area, created by the linker. It exists
178 in both executables and libraries. When the GOT is first
179 initialized , all the GOT entries relating to PLT fixups are
180 pointing to code back at PLT[0].
182 The special entries in the GOT are:
184 GOT[0] = linked list pointer used by the dynamic loader
185 GOT[1] = pointer to the reloc table for this module
186 GOT[2] = pointer to the fixup/resolver code
188 The first invocation of function call comes through and uses the
189 fixup/resolver code. On the entry to the fixup/resolver code:
193 stack[0] = return address (lr) of the function call
194 [r0, r1, r2, r3] are still the arguments to the function call
196 This is enough information for the fixup/resolver code to work
197 with. Before the fixup/resolver code returns, it actually calls
198 the requested function and repairs &GOT[n+3]. */
200 /* The constants below were determined by examining the following files
201 in the linux kernel sources:
203 arch/arm/kernel/signal.c
204 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
205 include/asm-arm/unistd.h
206 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
208 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
209 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
211 /* For ARM EABI, the syscall number is not in the SWI instruction
212 (instead it is loaded into r7). We recognize the pattern that
213 glibc uses... alternatively, we could arrange to do this by
214 function name, but they are not always exported. */
215 #define ARM_SET_R7_SIGRETURN 0xe3a07077
216 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
217 #define ARM_EABI_SYSCALL 0xef000000
220 arm_linux_sigtramp_cache (struct frame_info
*this_frame
,
221 struct trad_frame_cache
*this_cache
,
222 CORE_ADDR func
, int regs_offset
)
224 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
225 CORE_ADDR base
= sp
+ regs_offset
;
228 for (i
= 0; i
< 16; i
++)
229 trad_frame_set_reg_addr (this_cache
, i
, base
+ i
* 4);
231 trad_frame_set_reg_addr (this_cache
, ARM_PS_REGNUM
, base
+ 16 * 4);
233 /* The VFP or iWMMXt registers may be saved on the stack, but there's
234 no reliable way to restore them (yet). */
236 /* Save a frame ID. */
237 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
240 /* There are a couple of different possible stack layouts that
243 Before version 2.6.18, the kernel used completely independent
244 layouts for non-RT and RT signals. For non-RT signals the stack
245 began directly with a struct sigcontext. For RT signals the stack
246 began with two redundant pointers (to the siginfo and ucontext),
247 and then the siginfo and ucontext.
249 As of version 2.6.18, the non-RT signal frame layout starts with
250 a ucontext and the RT signal frame starts with a siginfo and then
251 a ucontext. Also, the ucontext now has a designated save area
252 for coprocessor registers.
254 For RT signals, it's easy to tell the difference: we look for
255 pinfo, the pointer to the siginfo. If it has the expected
256 value, we have an old layout. If it doesn't, we have the new
259 For non-RT signals, it's a bit harder. We need something in one
260 layout or the other with a recognizable offset and value. We can't
261 use the return trampoline, because ARM usually uses SA_RESTORER,
262 in which case the stack return trampoline is not filled in.
263 We can't use the saved stack pointer, because sigaltstack might
264 be in use. So for now we guess the new layout... */
266 /* There are three words (trap_no, error_code, oldmask) in
267 struct sigcontext before r0. */
268 #define ARM_SIGCONTEXT_R0 0xc
270 /* There are five words (uc_flags, uc_link, and three for uc_stack)
271 in the ucontext_t before the sigcontext. */
272 #define ARM_UCONTEXT_SIGCONTEXT 0x14
274 /* There are three elements in an rt_sigframe before the ucontext:
275 pinfo, puc, and info. The first two are pointers and the third
276 is a struct siginfo, with size 128 bytes. We could follow puc
277 to the ucontext, but it's simpler to skip the whole thing. */
278 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
279 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
281 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
283 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
286 arm_linux_sigreturn_init (const struct tramp_frame
*self
,
287 struct frame_info
*this_frame
,
288 struct trad_frame_cache
*this_cache
,
291 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
292 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
293 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
294 ULONGEST uc_flags
= read_memory_unsigned_integer (sp
, 4, byte_order
);
296 if (uc_flags
== ARM_NEW_SIGFRAME_MAGIC
)
297 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
298 ARM_UCONTEXT_SIGCONTEXT
299 + ARM_SIGCONTEXT_R0
);
301 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
306 arm_linux_rt_sigreturn_init (const struct tramp_frame
*self
,
307 struct frame_info
*this_frame
,
308 struct trad_frame_cache
*this_cache
,
311 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
312 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
313 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
314 ULONGEST pinfo
= read_memory_unsigned_integer (sp
, 4, byte_order
);
316 if (pinfo
== sp
+ ARM_OLD_RT_SIGFRAME_SIGINFO
)
317 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
318 ARM_OLD_RT_SIGFRAME_UCONTEXT
319 + ARM_UCONTEXT_SIGCONTEXT
320 + ARM_SIGCONTEXT_R0
);
322 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
323 ARM_NEW_RT_SIGFRAME_UCONTEXT
324 + ARM_UCONTEXT_SIGCONTEXT
325 + ARM_SIGCONTEXT_R0
);
328 static struct tramp_frame arm_linux_sigreturn_tramp_frame
= {
332 { ARM_LINUX_SIGRETURN_INSTR
, -1 },
333 { TRAMP_SENTINEL_INSN
}
335 arm_linux_sigreturn_init
338 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame
= {
342 { ARM_LINUX_RT_SIGRETURN_INSTR
, -1 },
343 { TRAMP_SENTINEL_INSN
}
345 arm_linux_rt_sigreturn_init
348 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame
= {
352 { ARM_SET_R7_SIGRETURN
, -1 },
353 { ARM_EABI_SYSCALL
, -1 },
354 { TRAMP_SENTINEL_INSN
}
356 arm_linux_sigreturn_init
359 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame
= {
363 { ARM_SET_R7_RT_SIGRETURN
, -1 },
364 { ARM_EABI_SYSCALL
, -1 },
365 { TRAMP_SENTINEL_INSN
}
367 arm_linux_rt_sigreturn_init
370 /* Core file and register set support. */
372 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
375 arm_linux_supply_gregset (const struct regset
*regset
,
376 struct regcache
*regcache
,
377 int regnum
, const void *gregs_buf
, size_t len
)
379 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
380 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
381 const gdb_byte
*gregs
= gregs_buf
;
384 gdb_byte pc_buf
[INT_REGISTER_SIZE
];
386 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
387 if (regnum
== -1 || regnum
== regno
)
388 regcache_raw_supply (regcache
, regno
,
389 gregs
+ INT_REGISTER_SIZE
* regno
);
391 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
394 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
395 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
397 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
398 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
401 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
403 reg_pc
= extract_unsigned_integer (gregs
404 + INT_REGISTER_SIZE
* ARM_PC_REGNUM
,
405 INT_REGISTER_SIZE
, byte_order
);
406 reg_pc
= gdbarch_addr_bits_remove (gdbarch
, reg_pc
);
407 store_unsigned_integer (pc_buf
, INT_REGISTER_SIZE
, byte_order
, reg_pc
);
408 regcache_raw_supply (regcache
, ARM_PC_REGNUM
, pc_buf
);
413 arm_linux_collect_gregset (const struct regset
*regset
,
414 const struct regcache
*regcache
,
415 int regnum
, void *gregs_buf
, size_t len
)
417 gdb_byte
*gregs
= gregs_buf
;
420 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
421 if (regnum
== -1 || regnum
== regno
)
422 regcache_raw_collect (regcache
, regno
,
423 gregs
+ INT_REGISTER_SIZE
* regno
);
425 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
428 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
429 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
431 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
432 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
435 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
436 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
437 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
440 /* Support for register format used by the NWFPE FPA emulator. */
442 #define typeNone 0x00
443 #define typeSingle 0x01
444 #define typeDouble 0x02
445 #define typeExtended 0x03
448 supply_nwfpe_register (struct regcache
*regcache
, int regno
,
449 const gdb_byte
*regs
)
451 const gdb_byte
*reg_data
;
453 gdb_byte buf
[FP_REGISTER_SIZE
];
455 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
456 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
457 memset (buf
, 0, FP_REGISTER_SIZE
);
462 memcpy (buf
, reg_data
, 4);
465 memcpy (buf
, reg_data
+ 4, 4);
466 memcpy (buf
+ 4, reg_data
, 4);
469 /* We want sign and exponent, then least significant bits,
470 then most significant. NWFPE does sign, most, least. */
471 memcpy (buf
, reg_data
, 4);
472 memcpy (buf
+ 4, reg_data
+ 8, 4);
473 memcpy (buf
+ 8, reg_data
+ 4, 4);
479 regcache_raw_supply (regcache
, regno
, buf
);
483 collect_nwfpe_register (const struct regcache
*regcache
, int regno
,
488 gdb_byte buf
[FP_REGISTER_SIZE
];
490 regcache_raw_collect (regcache
, regno
, buf
);
492 /* NOTE drow/2006-06-07: This code uses the tag already in the
493 register buffer. I've preserved that when moving the code
494 from the native file to the target file. But this doesn't
495 always make sense. */
497 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
498 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
503 memcpy (reg_data
, buf
, 4);
506 memcpy (reg_data
, buf
+ 4, 4);
507 memcpy (reg_data
+ 4, buf
, 4);
510 memcpy (reg_data
, buf
, 4);
511 memcpy (reg_data
+ 4, buf
+ 8, 4);
512 memcpy (reg_data
+ 8, buf
+ 4, 4);
520 arm_linux_supply_nwfpe (const struct regset
*regset
,
521 struct regcache
*regcache
,
522 int regnum
, const void *regs_buf
, size_t len
)
524 const gdb_byte
*regs
= regs_buf
;
527 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
528 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
529 regs
+ NWFPE_FPSR_OFFSET
);
531 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
532 if (regnum
== -1 || regnum
== regno
)
533 supply_nwfpe_register (regcache
, regno
, regs
);
537 arm_linux_collect_nwfpe (const struct regset
*regset
,
538 const struct regcache
*regcache
,
539 int regnum
, void *regs_buf
, size_t len
)
541 gdb_byte
*regs
= regs_buf
;
544 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
545 if (regnum
== -1 || regnum
== regno
)
546 collect_nwfpe_register (regcache
, regno
, regs
);
548 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
549 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
,
550 regs
+ INT_REGISTER_SIZE
* ARM_FPS_REGNUM
);
553 /* Return the appropriate register set for the core section identified
554 by SECT_NAME and SECT_SIZE. */
556 static const struct regset
*
557 arm_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
558 const char *sect_name
, size_t sect_size
)
560 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
562 if (strcmp (sect_name
, ".reg") == 0
563 && sect_size
== ARM_LINUX_SIZEOF_GREGSET
)
565 if (tdep
->gregset
== NULL
)
566 tdep
->gregset
= regset_alloc (gdbarch
, arm_linux_supply_gregset
,
567 arm_linux_collect_gregset
);
568 return tdep
->gregset
;
571 if (strcmp (sect_name
, ".reg2") == 0
572 && sect_size
== ARM_LINUX_SIZEOF_NWFPE
)
574 if (tdep
->fpregset
== NULL
)
575 tdep
->fpregset
= regset_alloc (gdbarch
, arm_linux_supply_nwfpe
,
576 arm_linux_collect_nwfpe
);
577 return tdep
->fpregset
;
583 /* Insert a single step breakpoint at the next executed instruction. */
586 arm_linux_software_single_step (struct frame_info
*frame
)
588 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
589 struct address_space
*aspace
= get_frame_address_space (frame
);
590 CORE_ADDR next_pc
= arm_get_next_pc (frame
, get_frame_pc (frame
));
592 /* The Linux kernel offers some user-mode helpers in a high page. We can
593 not read this page (as of 2.6.23), and even if we could then we couldn't
594 set breakpoints in it, and even if we could then the atomic operations
595 would fail when interrupted. They are all called as functions and return
596 to the address in LR, so step to there instead. */
597 if (next_pc
> 0xffff0000)
598 next_pc
= get_frame_register_unsigned (frame
, ARM_LR_REGNUM
);
600 insert_single_step_breakpoint (gdbarch
, aspace
, next_pc
);
605 /* Support for displaced stepping of Linux SVC instructions. */
608 arm_linux_cleanup_svc (struct gdbarch
*gdbarch ATTRIBUTE_UNUSED
,
609 struct regcache
*regs
,
610 struct displaced_step_closure
*dsc
)
612 CORE_ADDR from
= dsc
->insn_addr
;
613 ULONGEST apparent_pc
;
616 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &apparent_pc
);
618 within_scratch
= (apparent_pc
>= dsc
->scratch_base
619 && apparent_pc
< (dsc
->scratch_base
620 + DISPLACED_MODIFIED_INSNS
* 4 + 4));
624 fprintf_unfiltered (gdb_stdlog
, "displaced: PC is apparently %.8lx after "
625 "SVC step ", (unsigned long) apparent_pc
);
627 fprintf_unfiltered (gdb_stdlog
, "(within scratch space)\n");
629 fprintf_unfiltered (gdb_stdlog
, "(outside scratch space)\n");
633 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, from
+ 4, BRANCH_WRITE_PC
);
637 arm_linux_copy_svc (struct gdbarch
*gdbarch
, uint32_t insn
, CORE_ADDR to
,
638 struct regcache
*regs
, struct displaced_step_closure
*dsc
)
640 CORE_ADDR from
= dsc
->insn_addr
;
641 struct frame_info
*frame
;
642 unsigned int svc_number
= displaced_read_reg (regs
, from
, 7);
645 fprintf_unfiltered (gdb_stdlog
, "displaced: copying Linux svc insn %.8lx\n",
646 (unsigned long) insn
);
648 frame
= get_current_frame ();
650 /* Is this a sigreturn or rt_sigreturn syscall? Note: these are only useful
652 if (svc_number
== 119 || svc_number
== 173)
654 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
657 struct symtab_and_line sal
;
660 fprintf_unfiltered (gdb_stdlog
, "displaced: found "
661 "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
662 (unsigned long) get_frame_pc (frame
));
664 return_to
= frame_unwind_caller_pc (frame
);
666 fprintf_unfiltered (gdb_stdlog
, "displaced: unwind pc = %lx. "
667 "Setting momentary breakpoint.\n", (unsigned long) return_to
);
669 gdb_assert (inferior_thread ()->step_resume_breakpoint
== NULL
);
671 sal
= find_pc_line (return_to
, 0);
673 sal
.section
= find_pc_overlay (return_to
);
676 frame
= get_prev_frame (frame
);
680 inferior_thread ()->step_resume_breakpoint
681 = set_momentary_breakpoint (gdbarch
, sal
, get_frame_id (frame
),
684 /* We need to make sure we actually insert the momentary
685 breakpoint set above. */
686 insert_breakpoints ();
688 else if (debug_displaced
)
689 fprintf_unfiltered (gdb_stderr
, "displaced: couldn't find previous "
690 "frame to set momentary breakpoint for "
691 "sigreturn/rt_sigreturn\n");
693 else if (debug_displaced
)
694 fprintf_unfiltered (gdb_stdlog
, "displaced: sigreturn/rt_sigreturn "
695 "SVC call not in signal trampoline frame\n");
698 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
699 location, else nothing.
700 Insn: unmodified svc.
701 Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
702 else leave pc alone. */
704 dsc
->modinsn
[0] = insn
;
706 dsc
->cleanup
= &arm_linux_cleanup_svc
;
707 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
709 dsc
->wrote_to_pc
= 1;
715 /* The following two functions implement single-stepping over calls to Linux
716 kernel helper routines, which perform e.g. atomic operations on architecture
717 variants which don't support them natively.
719 When this function is called, the PC will be pointing at the kernel helper
720 (at an address inaccessible to GDB), and r14 will point to the return
721 address. Displaced stepping always executes code in the copy area:
722 so, make the copy-area instruction branch back to the kernel helper (the
723 "from" address), and make r14 point to the breakpoint in the copy area. In
724 that way, we regain control once the kernel helper returns, and can clean
725 up appropriately (as if we had just returned from the kernel helper as it
726 would have been called from the non-displaced location). */
729 cleanup_kernel_helper_return (struct gdbarch
*gdbarch ATTRIBUTE_UNUSED
,
730 struct regcache
*regs
,
731 struct displaced_step_closure
*dsc
)
733 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, dsc
->tmp
[0], CANNOT_WRITE_PC
);
734 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, dsc
->tmp
[0], BRANCH_WRITE_PC
);
738 arm_catch_kernel_helper_return (struct gdbarch
*gdbarch
, CORE_ADDR from
,
739 CORE_ADDR to
, struct regcache
*regs
,
740 struct displaced_step_closure
*dsc
)
742 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
745 dsc
->insn_addr
= from
;
746 dsc
->cleanup
= &cleanup_kernel_helper_return
;
747 /* Say we wrote to the PC, else cleanup will set PC to the next
748 instruction in the helper, which isn't helpful. */
749 dsc
->wrote_to_pc
= 1;
751 /* Preparation: tmp[0] <- r14
752 r14 <- <scratch space>+4
753 *(<scratch space>+8) <- from
754 Insn: ldr pc, [r14, #4]
755 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
757 dsc
->tmp
[0] = displaced_read_reg (regs
, from
, ARM_LR_REGNUM
);
758 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, (ULONGEST
) to
+ 4,
760 write_memory_unsigned_integer (to
+ 8, 4, byte_order
, from
);
762 dsc
->modinsn
[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
765 /* Linux-specific displaced step instruction copying function. Detects when
766 the program has stepped into a Linux kernel helper routine (which must be
767 handled as a special case), falling back to arm_displaced_step_copy_insn()
770 static struct displaced_step_closure
*
771 arm_linux_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
772 CORE_ADDR from
, CORE_ADDR to
,
773 struct regcache
*regs
)
775 struct displaced_step_closure
*dsc
776 = xmalloc (sizeof (struct displaced_step_closure
));
778 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
779 stop at the return location. */
780 if (from
> 0xffff0000)
783 fprintf_unfiltered (gdb_stdlog
, "displaced: detected kernel helper "
784 "at %.8lx\n", (unsigned long) from
);
786 arm_catch_kernel_helper_return (gdbarch
, from
, to
, regs
, dsc
);
790 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
791 uint32_t insn
= read_memory_unsigned_integer (from
, 4, byte_order
);
794 fprintf_unfiltered (gdb_stdlog
, "displaced: stepping insn %.8lx "
795 "at %.8lx\n", (unsigned long) insn
,
796 (unsigned long) from
);
798 /* Override the default handling of SVC instructions. */
799 dsc
->u
.svc
.copy_svc_os
= arm_linux_copy_svc
;
801 arm_process_displaced_insn (gdbarch
, insn
, from
, to
, regs
, dsc
);
804 arm_displaced_init_closure (gdbarch
, from
, to
, dsc
);
810 arm_linux_init_abi (struct gdbarch_info info
,
811 struct gdbarch
*gdbarch
)
813 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
815 tdep
->lowest_pc
= 0x8000;
816 if (info
.byte_order
== BFD_ENDIAN_BIG
)
818 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
819 tdep
->arm_breakpoint
= eabi_linux_arm_be_breakpoint
;
821 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
822 tdep
->thumb_breakpoint
= arm_linux_thumb_be_breakpoint
;
826 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
827 tdep
->arm_breakpoint
= eabi_linux_arm_le_breakpoint
;
829 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
830 tdep
->thumb_breakpoint
= arm_linux_thumb_le_breakpoint
;
832 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
833 tdep
->thumb_breakpoint_size
= sizeof (arm_linux_thumb_le_breakpoint
);
835 if (tdep
->fp_model
== ARM_FLOAT_AUTO
)
836 tdep
->fp_model
= ARM_FLOAT_FPA
;
838 tdep
->jb_pc
= ARM_LINUX_JB_PC
;
839 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
841 set_solib_svr4_fetch_link_map_offsets
842 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
844 /* Single stepping. */
845 set_gdbarch_software_single_step (gdbarch
, arm_linux_software_single_step
);
847 /* Shared library handling. */
848 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
849 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
851 /* Enable TLS support. */
852 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
853 svr4_fetch_objfile_link_map
);
855 tramp_frame_prepend_unwinder (gdbarch
,
856 &arm_linux_sigreturn_tramp_frame
);
857 tramp_frame_prepend_unwinder (gdbarch
,
858 &arm_linux_rt_sigreturn_tramp_frame
);
859 tramp_frame_prepend_unwinder (gdbarch
,
860 &arm_eabi_linux_sigreturn_tramp_frame
);
861 tramp_frame_prepend_unwinder (gdbarch
,
862 &arm_eabi_linux_rt_sigreturn_tramp_frame
);
864 /* Core file support. */
865 set_gdbarch_regset_from_core_section (gdbarch
,
866 arm_linux_regset_from_core_section
);
868 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
870 /* Displaced stepping. */
871 set_gdbarch_displaced_step_copy_insn (gdbarch
,
872 arm_linux_displaced_step_copy_insn
);
873 set_gdbarch_displaced_step_fixup (gdbarch
, arm_displaced_step_fixup
);
874 set_gdbarch_displaced_step_free_closure (gdbarch
,
875 simple_displaced_step_free_closure
);
876 set_gdbarch_displaced_step_location (gdbarch
, displaced_step_at_entry_point
);
879 /* Provide a prototype to silence -Wmissing-prototypes. */
880 extern initialize_file_ftype _initialize_arm_linux_tdep
;
883 _initialize_arm_linux_tdep (void)
885 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,