1 /* GNU/Linux on ARM target support.
3 Copyright (C) 1999-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "floatformat.h"
29 #include "solib-svr4.h"
32 #include "trad-frame.h"
33 #include "tramp-frame.h"
34 #include "breakpoint.h"
36 #include "xml-syscall.h"
39 #include "arm-linux-tdep.h"
40 #include "linux-tdep.h"
41 #include "glibc-tdep.h"
42 #include "arch-utils.h"
45 #include "gdbthread.h"
48 #include "record-full.h"
49 #include "linux-record.h"
51 #include "cli/cli-utils.h"
52 #include "stap-probe.h"
53 #include "parser-defs.h"
54 #include "user-regs.h"
56 #include "elf/common.h"
59 extern int arm_apcs_32
;
61 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
62 is to execute a particular software interrupt, rather than use a
63 particular undefined instruction to provoke a trap. Upon exection
64 of the software interrupt the kernel stops the inferior with a
65 SIGTRAP, and wakes the debugger. */
67 static const gdb_byte arm_linux_arm_le_breakpoint
[] = { 0x01, 0x00, 0x9f, 0xef };
69 static const gdb_byte arm_linux_arm_be_breakpoint
[] = { 0xef, 0x9f, 0x00, 0x01 };
71 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
72 the operand of the swi if old-ABI compatibility is disabled. Therefore,
73 use an undefined instruction instead. This is supported as of kernel
74 version 2.5.70 (May 2003), so should be a safe assumption for EABI
77 static const gdb_byte eabi_linux_arm_le_breakpoint
[] = { 0xf0, 0x01, 0xf0, 0xe7 };
79 static const gdb_byte eabi_linux_arm_be_breakpoint
[] = { 0xe7, 0xf0, 0x01, 0xf0 };
81 /* All the kernels which support Thumb support using a specific undefined
82 instruction for the Thumb breakpoint. */
84 static const gdb_byte arm_linux_thumb_be_breakpoint
[] = {0xde, 0x01};
86 static const gdb_byte arm_linux_thumb_le_breakpoint
[] = {0x01, 0xde};
88 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
89 we must use a length-appropriate breakpoint for 32-bit Thumb
90 instructions. See also thumb_get_next_pc. */
92 static const gdb_byte arm_linux_thumb2_be_breakpoint
[] = { 0xf7, 0xf0, 0xa0, 0x00 };
94 static const gdb_byte arm_linux_thumb2_le_breakpoint
[] = { 0xf0, 0xf7, 0x00, 0xa0 };
96 /* Description of the longjmp buffer. The buffer is treated as an array of
97 elements of size ARM_LINUX_JB_ELEMENT_SIZE.
99 The location of saved registers in this buffer (in particular the PC
100 to use after longjmp is called) varies depending on the ABI (in
101 particular the FP model) and also (possibly) the C Library.
103 For glibc, eglibc, and uclibc the following holds: If the FP model is
104 SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
105 buffer. This is also true for the SoftFPA model. However, for the FPA
106 model the PC is at offset 21 in the buffer. */
107 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
108 #define ARM_LINUX_JB_PC_FPA 21
109 #define ARM_LINUX_JB_PC_EABI 9
112 Dynamic Linking on ARM GNU/Linux
113 --------------------------------
115 Note: PLT = procedure linkage table
116 GOT = global offset table
118 As much as possible, ELF dynamic linking defers the resolution of
119 jump/call addresses until the last minute. The technique used is
120 inspired by the i386 ELF design, and is based on the following
123 1) The calling technique should not force a change in the assembly
124 code produced for apps; it MAY cause changes in the way assembly
125 code is produced for position independent code (i.e. shared
128 2) The technique must be such that all executable areas must not be
129 modified; and any modified areas must not be executed.
131 To do this, there are three steps involved in a typical jump:
135 3) using a pointer from the GOT
137 When the executable or library is first loaded, each GOT entry is
138 initialized to point to the code which implements dynamic name
139 resolution and code finding. This is normally a function in the
140 program interpreter (on ARM GNU/Linux this is usually
141 ld-linux.so.2, but it does not have to be). On the first
142 invocation, the function is located and the GOT entry is replaced
143 with the real function address. Subsequent calls go through steps
144 1, 2 and 3 and end up calling the real code.
151 This is typical ARM code using the 26 bit relative branch or branch
152 and link instructions. The target of the instruction
153 (function_call is usually the address of the function to be called.
154 In position independent code, the target of the instruction is
155 actually an entry in the PLT when calling functions in a shared
156 library. Note that this call is identical to a normal function
157 call, only the target differs.
161 The PLT is a synthetic area, created by the linker. It exists in
162 both executables and libraries. It is an array of stubs, one per
163 imported function call. It looks like this:
166 str lr, [sp, #-4]! @push the return address (lr)
167 ldr lr, [pc, #16] @load from 6 words ahead
168 add lr, pc, lr @form an address for GOT[0]
169 ldr pc, [lr, #8]! @jump to the contents of that addr
171 The return address (lr) is pushed on the stack and used for
172 calculations. The load on the second line loads the lr with
173 &GOT[3] - . - 20. The addition on the third leaves:
175 lr = (&GOT[3] - . - 20) + (. + 8)
179 On the fourth line, the pc and lr are both updated, so that:
185 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
186 "tight", but allows us to keep all the PLT entries the same size.
189 ldr ip, [pc, #4] @load offset from gotoff
190 add ip, pc, ip @add the offset to the pc
191 ldr pc, [ip] @jump to that address
192 gotoff: .word GOT[n+3] - .
194 The load on the first line, gets an offset from the fourth word of
195 the PLT entry. The add on the second line makes ip = &GOT[n+3],
196 which contains either a pointer to PLT[0] (the fixup trampoline) or
197 a pointer to the actual code.
201 The GOT contains helper pointers for both code (PLT) fixups and
202 data fixups. The first 3 entries of the GOT are special. The next
203 M entries (where M is the number of entries in the PLT) belong to
204 the PLT fixups. The next D (all remaining) entries belong to
205 various data fixups. The actual size of the GOT is 3 + M + D.
207 The GOT is also a synthetic area, created by the linker. It exists
208 in both executables and libraries. When the GOT is first
209 initialized , all the GOT entries relating to PLT fixups are
210 pointing to code back at PLT[0].
212 The special entries in the GOT are:
214 GOT[0] = linked list pointer used by the dynamic loader
215 GOT[1] = pointer to the reloc table for this module
216 GOT[2] = pointer to the fixup/resolver code
218 The first invocation of function call comes through and uses the
219 fixup/resolver code. On the entry to the fixup/resolver code:
223 stack[0] = return address (lr) of the function call
224 [r0, r1, r2, r3] are still the arguments to the function call
226 This is enough information for the fixup/resolver code to work
227 with. Before the fixup/resolver code returns, it actually calls
228 the requested function and repairs &GOT[n+3]. */
230 /* The constants below were determined by examining the following files
231 in the linux kernel sources:
233 arch/arm/kernel/signal.c
234 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
235 include/asm-arm/unistd.h
236 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
238 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
239 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
241 /* For ARM EABI, the syscall number is not in the SWI instruction
242 (instead it is loaded into r7). We recognize the pattern that
243 glibc uses... alternatively, we could arrange to do this by
244 function name, but they are not always exported. */
245 #define ARM_SET_R7_SIGRETURN 0xe3a07077
246 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
247 #define ARM_EABI_SYSCALL 0xef000000
249 /* Equivalent patterns for Thumb2. */
250 #define THUMB2_SET_R7_SIGRETURN1 0xf04f
251 #define THUMB2_SET_R7_SIGRETURN2 0x0777
252 #define THUMB2_SET_R7_RT_SIGRETURN1 0xf04f
253 #define THUMB2_SET_R7_RT_SIGRETURN2 0x07ad
254 #define THUMB2_EABI_SYSCALL 0xdf00
256 /* OABI syscall restart trampoline, used for EABI executables too
257 whenever OABI support has been enabled in the kernel. */
258 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
259 #define ARM_LDR_PC_SP_12 0xe49df00c
260 #define ARM_LDR_PC_SP_4 0xe49df004
263 arm_linux_sigtramp_cache (struct frame_info
*this_frame
,
264 struct trad_frame_cache
*this_cache
,
265 CORE_ADDR func
, int regs_offset
)
267 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
268 CORE_ADDR base
= sp
+ regs_offset
;
271 for (i
= 0; i
< 16; i
++)
272 trad_frame_set_reg_addr (this_cache
, i
, base
+ i
* 4);
274 trad_frame_set_reg_addr (this_cache
, ARM_PS_REGNUM
, base
+ 16 * 4);
276 /* The VFP or iWMMXt registers may be saved on the stack, but there's
277 no reliable way to restore them (yet). */
279 /* Save a frame ID. */
280 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
283 /* There are a couple of different possible stack layouts that
286 Before version 2.6.18, the kernel used completely independent
287 layouts for non-RT and RT signals. For non-RT signals the stack
288 began directly with a struct sigcontext. For RT signals the stack
289 began with two redundant pointers (to the siginfo and ucontext),
290 and then the siginfo and ucontext.
292 As of version 2.6.18, the non-RT signal frame layout starts with
293 a ucontext and the RT signal frame starts with a siginfo and then
294 a ucontext. Also, the ucontext now has a designated save area
295 for coprocessor registers.
297 For RT signals, it's easy to tell the difference: we look for
298 pinfo, the pointer to the siginfo. If it has the expected
299 value, we have an old layout. If it doesn't, we have the new
302 For non-RT signals, it's a bit harder. We need something in one
303 layout or the other with a recognizable offset and value. We can't
304 use the return trampoline, because ARM usually uses SA_RESTORER,
305 in which case the stack return trampoline is not filled in.
306 We can't use the saved stack pointer, because sigaltstack might
307 be in use. So for now we guess the new layout... */
309 /* There are three words (trap_no, error_code, oldmask) in
310 struct sigcontext before r0. */
311 #define ARM_SIGCONTEXT_R0 0xc
313 /* There are five words (uc_flags, uc_link, and three for uc_stack)
314 in the ucontext_t before the sigcontext. */
315 #define ARM_UCONTEXT_SIGCONTEXT 0x14
317 /* There are three elements in an rt_sigframe before the ucontext:
318 pinfo, puc, and info. The first two are pointers and the third
319 is a struct siginfo, with size 128 bytes. We could follow puc
320 to the ucontext, but it's simpler to skip the whole thing. */
321 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
322 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
324 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
326 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
329 arm_linux_sigreturn_init (const struct tramp_frame
*self
,
330 struct frame_info
*this_frame
,
331 struct trad_frame_cache
*this_cache
,
334 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
335 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
336 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
337 ULONGEST uc_flags
= read_memory_unsigned_integer (sp
, 4, byte_order
);
339 if (uc_flags
== ARM_NEW_SIGFRAME_MAGIC
)
340 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
341 ARM_UCONTEXT_SIGCONTEXT
342 + ARM_SIGCONTEXT_R0
);
344 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
349 arm_linux_rt_sigreturn_init (const struct tramp_frame
*self
,
350 struct frame_info
*this_frame
,
351 struct trad_frame_cache
*this_cache
,
354 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
355 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
356 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
357 ULONGEST pinfo
= read_memory_unsigned_integer (sp
, 4, byte_order
);
359 if (pinfo
== sp
+ ARM_OLD_RT_SIGFRAME_SIGINFO
)
360 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
361 ARM_OLD_RT_SIGFRAME_UCONTEXT
362 + ARM_UCONTEXT_SIGCONTEXT
363 + ARM_SIGCONTEXT_R0
);
365 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
366 ARM_NEW_RT_SIGFRAME_UCONTEXT
367 + ARM_UCONTEXT_SIGCONTEXT
368 + ARM_SIGCONTEXT_R0
);
372 arm_linux_restart_syscall_init (const struct tramp_frame
*self
,
373 struct frame_info
*this_frame
,
374 struct trad_frame_cache
*this_cache
,
377 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
378 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
379 CORE_ADDR pc
= get_frame_memory_unsigned (this_frame
, sp
, 4);
380 CORE_ADDR cpsr
= get_frame_register_unsigned (this_frame
, ARM_PS_REGNUM
);
381 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
384 /* There are two variants of this trampoline; with older kernels, the
385 stub is placed on the stack, while newer kernels use the stub from
386 the vector page. They are identical except that the older version
387 increments SP by 12 (to skip stored PC and the stub itself), while
388 the newer version increments SP only by 4 (just the stored PC). */
389 if (self
->insn
[1].bytes
== ARM_LDR_PC_SP_4
)
394 /* Update Thumb bit in CPSR. */
400 /* Remove Thumb bit from PC. */
401 pc
= gdbarch_addr_bits_remove (gdbarch
, pc
);
403 /* Save previous register values. */
404 trad_frame_set_reg_value (this_cache
, ARM_SP_REGNUM
, sp
+ sp_offset
);
405 trad_frame_set_reg_value (this_cache
, ARM_PC_REGNUM
, pc
);
406 trad_frame_set_reg_value (this_cache
, ARM_PS_REGNUM
, cpsr
);
408 /* Save a frame ID. */
409 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
412 static struct tramp_frame arm_linux_sigreturn_tramp_frame
= {
416 { ARM_LINUX_SIGRETURN_INSTR
, -1 },
417 { TRAMP_SENTINEL_INSN
}
419 arm_linux_sigreturn_init
422 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame
= {
426 { ARM_LINUX_RT_SIGRETURN_INSTR
, -1 },
427 { TRAMP_SENTINEL_INSN
}
429 arm_linux_rt_sigreturn_init
432 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame
= {
436 { ARM_SET_R7_SIGRETURN
, -1 },
437 { ARM_EABI_SYSCALL
, -1 },
438 { TRAMP_SENTINEL_INSN
}
440 arm_linux_sigreturn_init
443 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame
= {
447 { ARM_SET_R7_RT_SIGRETURN
, -1 },
448 { ARM_EABI_SYSCALL
, -1 },
449 { TRAMP_SENTINEL_INSN
}
451 arm_linux_rt_sigreturn_init
454 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame
= {
458 { THUMB2_SET_R7_SIGRETURN1
, -1 },
459 { THUMB2_SET_R7_SIGRETURN2
, -1 },
460 { THUMB2_EABI_SYSCALL
, -1 },
461 { TRAMP_SENTINEL_INSN
}
463 arm_linux_sigreturn_init
466 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame
= {
470 { THUMB2_SET_R7_RT_SIGRETURN1
, -1 },
471 { THUMB2_SET_R7_RT_SIGRETURN2
, -1 },
472 { THUMB2_EABI_SYSCALL
, -1 },
473 { TRAMP_SENTINEL_INSN
}
475 arm_linux_rt_sigreturn_init
478 static struct tramp_frame arm_linux_restart_syscall_tramp_frame
= {
482 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
483 { ARM_LDR_PC_SP_12
, -1 },
484 { TRAMP_SENTINEL_INSN
}
486 arm_linux_restart_syscall_init
489 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame
= {
493 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
494 { ARM_LDR_PC_SP_4
, -1 },
495 { TRAMP_SENTINEL_INSN
}
497 arm_linux_restart_syscall_init
500 /* Core file and register set support. */
502 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
505 arm_linux_supply_gregset (const struct regset
*regset
,
506 struct regcache
*regcache
,
507 int regnum
, const void *gregs_buf
, size_t len
)
509 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
510 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
511 const gdb_byte
*gregs
= gregs_buf
;
514 gdb_byte pc_buf
[INT_REGISTER_SIZE
];
516 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
517 if (regnum
== -1 || regnum
== regno
)
518 regcache_raw_supply (regcache
, regno
,
519 gregs
+ INT_REGISTER_SIZE
* regno
);
521 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
524 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
525 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
527 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
528 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
531 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
533 reg_pc
= extract_unsigned_integer (gregs
534 + INT_REGISTER_SIZE
* ARM_PC_REGNUM
,
535 INT_REGISTER_SIZE
, byte_order
);
536 reg_pc
= gdbarch_addr_bits_remove (gdbarch
, reg_pc
);
537 store_unsigned_integer (pc_buf
, INT_REGISTER_SIZE
, byte_order
, reg_pc
);
538 regcache_raw_supply (regcache
, ARM_PC_REGNUM
, pc_buf
);
543 arm_linux_collect_gregset (const struct regset
*regset
,
544 const struct regcache
*regcache
,
545 int regnum
, void *gregs_buf
, size_t len
)
547 gdb_byte
*gregs
= gregs_buf
;
550 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
551 if (regnum
== -1 || regnum
== regno
)
552 regcache_raw_collect (regcache
, regno
,
553 gregs
+ INT_REGISTER_SIZE
* regno
);
555 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
558 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
559 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
561 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
562 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
565 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
566 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
567 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
570 /* Support for register format used by the NWFPE FPA emulator. */
572 #define typeNone 0x00
573 #define typeSingle 0x01
574 #define typeDouble 0x02
575 #define typeExtended 0x03
578 supply_nwfpe_register (struct regcache
*regcache
, int regno
,
579 const gdb_byte
*regs
)
581 const gdb_byte
*reg_data
;
583 gdb_byte buf
[FP_REGISTER_SIZE
];
585 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
586 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
587 memset (buf
, 0, FP_REGISTER_SIZE
);
592 memcpy (buf
, reg_data
, 4);
595 memcpy (buf
, reg_data
+ 4, 4);
596 memcpy (buf
+ 4, reg_data
, 4);
599 /* We want sign and exponent, then least significant bits,
600 then most significant. NWFPE does sign, most, least. */
601 memcpy (buf
, reg_data
, 4);
602 memcpy (buf
+ 4, reg_data
+ 8, 4);
603 memcpy (buf
+ 8, reg_data
+ 4, 4);
609 regcache_raw_supply (regcache
, regno
, buf
);
613 collect_nwfpe_register (const struct regcache
*regcache
, int regno
,
618 gdb_byte buf
[FP_REGISTER_SIZE
];
620 regcache_raw_collect (regcache
, regno
, buf
);
622 /* NOTE drow/2006-06-07: This code uses the tag already in the
623 register buffer. I've preserved that when moving the code
624 from the native file to the target file. But this doesn't
625 always make sense. */
627 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
628 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
633 memcpy (reg_data
, buf
, 4);
636 memcpy (reg_data
, buf
+ 4, 4);
637 memcpy (reg_data
+ 4, buf
, 4);
640 memcpy (reg_data
, buf
, 4);
641 memcpy (reg_data
+ 4, buf
+ 8, 4);
642 memcpy (reg_data
+ 8, buf
+ 4, 4);
650 arm_linux_supply_nwfpe (const struct regset
*regset
,
651 struct regcache
*regcache
,
652 int regnum
, const void *regs_buf
, size_t len
)
654 const gdb_byte
*regs
= regs_buf
;
657 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
658 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
659 regs
+ NWFPE_FPSR_OFFSET
);
661 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
662 if (regnum
== -1 || regnum
== regno
)
663 supply_nwfpe_register (regcache
, regno
, regs
);
667 arm_linux_collect_nwfpe (const struct regset
*regset
,
668 const struct regcache
*regcache
,
669 int regnum
, void *regs_buf
, size_t len
)
671 gdb_byte
*regs
= regs_buf
;
674 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
675 if (regnum
== -1 || regnum
== regno
)
676 collect_nwfpe_register (regcache
, regno
, regs
);
678 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
679 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
,
680 regs
+ INT_REGISTER_SIZE
* ARM_FPS_REGNUM
);
683 /* Support VFP register format. */
685 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
688 arm_linux_supply_vfp (const struct regset
*regset
,
689 struct regcache
*regcache
,
690 int regnum
, const void *regs_buf
, size_t len
)
692 const gdb_byte
*regs
= regs_buf
;
695 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
696 regcache_raw_supply (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
698 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
699 if (regnum
== -1 || regnum
== regno
)
700 regcache_raw_supply (regcache
, regno
,
701 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
705 arm_linux_collect_vfp (const struct regset
*regset
,
706 const struct regcache
*regcache
,
707 int regnum
, void *regs_buf
, size_t len
)
709 gdb_byte
*regs
= regs_buf
;
712 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
713 regcache_raw_collect (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
715 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
716 if (regnum
== -1 || regnum
== regno
)
717 regcache_raw_collect (regcache
, regno
,
718 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
721 static const struct regset arm_linux_gregset
=
723 NULL
, arm_linux_supply_gregset
, arm_linux_collect_gregset
726 static const struct regset arm_linux_fpregset
=
728 NULL
, arm_linux_supply_nwfpe
, arm_linux_collect_nwfpe
731 static const struct regset arm_linux_vfpregset
=
733 NULL
, arm_linux_supply_vfp
, arm_linux_collect_vfp
736 /* Return the appropriate register set for the core section identified
737 by SECT_NAME and SECT_SIZE. */
739 static const struct regset
*
740 arm_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
741 const char *sect_name
, size_t sect_size
)
743 if (strcmp (sect_name
, ".reg") == 0
744 && sect_size
== ARM_LINUX_SIZEOF_GREGSET
)
745 return &arm_linux_gregset
;
747 if (strcmp (sect_name
, ".reg2") == 0
748 && sect_size
== ARM_LINUX_SIZEOF_NWFPE
)
749 return &arm_linux_fpregset
;
751 if (strcmp (sect_name
, ".reg-arm-vfp") == 0
752 && sect_size
== ARM_LINUX_SIZEOF_VFP
)
753 return &arm_linux_vfpregset
;
758 /* Core file register set sections. */
760 static struct core_regset_section arm_linux_fpa_regset_sections
[] =
762 { ".reg", ARM_LINUX_SIZEOF_GREGSET
, "general-purpose" },
763 { ".reg2", ARM_LINUX_SIZEOF_NWFPE
, "FPA floating-point" },
767 static struct core_regset_section arm_linux_vfp_regset_sections
[] =
769 { ".reg", ARM_LINUX_SIZEOF_GREGSET
, "general-purpose" },
770 { ".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP
, "VFP floating-point" },
774 /* Determine target description from core file. */
776 static const struct target_desc
*
777 arm_linux_core_read_description (struct gdbarch
*gdbarch
,
778 struct target_ops
*target
,
781 CORE_ADDR arm_hwcap
= 0;
783 if (target_auxv_search (target
, AT_HWCAP
, &arm_hwcap
) != 1)
786 if (arm_hwcap
& HWCAP_VFP
)
788 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
789 Neon with VFPv3-D32. */
790 if (arm_hwcap
& HWCAP_NEON
)
791 return tdesc_arm_with_neon
;
792 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
793 return tdesc_arm_with_vfpv3
;
795 return tdesc_arm_with_vfpv2
;
802 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
803 return 1. In addition, set IS_THUMB depending on whether we
804 will return to ARM or Thumb code. Return 0 if it is not a
805 rt_sigreturn/sigreturn syscall. */
807 arm_linux_sigreturn_return_addr (struct frame_info
*frame
,
808 unsigned long svc_number
,
809 CORE_ADDR
*pc
, int *is_thumb
)
811 /* Is this a sigreturn or rt_sigreturn syscall? */
812 if (svc_number
== 119 || svc_number
== 173)
814 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
816 ULONGEST t_bit
= arm_psr_thumb_bit (frame_unwind_arch (frame
));
818 = frame_unwind_register_unsigned (frame
, ARM_PS_REGNUM
);
820 *is_thumb
= (cpsr
& t_bit
) != 0;
821 *pc
= frame_unwind_caller_pc (frame
);
828 /* At a ptrace syscall-stop, return the syscall number. This either
829 comes from the SWI instruction (OABI) or from r7 (EABI).
831 When the function fails, it should return -1. */
834 arm_linux_get_syscall_number (struct gdbarch
*gdbarch
,
837 struct regcache
*regs
= get_thread_regcache (ptid
);
838 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
842 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
844 ULONGEST svc_number
= -1;
846 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &pc
);
847 regcache_cooked_read_unsigned (regs
, ARM_PS_REGNUM
, &cpsr
);
848 is_thumb
= (cpsr
& t_bit
) != 0;
852 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
856 enum bfd_endian byte_order_for_code
=
857 gdbarch_byte_order_for_code (gdbarch
);
859 /* PC gets incremented before the syscall-stop, so read the
860 previous instruction. */
861 unsigned long this_instr
=
862 read_memory_unsigned_integer (pc
- 4, 4, byte_order_for_code
);
864 unsigned long svc_operand
= (0x00ffffff & this_instr
);
869 svc_number
= svc_operand
- 0x900000;
874 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
881 /* When FRAME is at a syscall instruction, return the PC of the next
882 instruction to be executed. */
885 arm_linux_syscall_next_pc (struct frame_info
*frame
)
887 CORE_ADDR pc
= get_frame_pc (frame
);
888 CORE_ADDR return_addr
= 0;
889 int is_thumb
= arm_frame_is_thumb (frame
);
890 ULONGEST svc_number
= 0;
894 svc_number
= get_frame_register_unsigned (frame
, 7);
895 return_addr
= pc
+ 2;
899 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
900 enum bfd_endian byte_order_for_code
=
901 gdbarch_byte_order_for_code (gdbarch
);
902 unsigned long this_instr
=
903 read_memory_unsigned_integer (pc
, 4, byte_order_for_code
);
905 unsigned long svc_operand
= (0x00ffffff & this_instr
);
906 if (svc_operand
) /* OABI. */
908 svc_number
= svc_operand
- 0x900000;
912 svc_number
= get_frame_register_unsigned (frame
, 7);
915 return_addr
= pc
+ 4;
918 arm_linux_sigreturn_return_addr (frame
, svc_number
, &return_addr
, &is_thumb
);
920 /* Addresses for calling Thumb functions have the bit 0 set. */
928 /* Insert a single step breakpoint at the next executed instruction. */
931 arm_linux_software_single_step (struct frame_info
*frame
)
933 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
934 struct address_space
*aspace
= get_frame_address_space (frame
);
937 if (arm_deal_with_atomic_sequence (frame
))
940 next_pc
= arm_get_next_pc (frame
, get_frame_pc (frame
));
942 /* The Linux kernel offers some user-mode helpers in a high page. We can
943 not read this page (as of 2.6.23), and even if we could then we couldn't
944 set breakpoints in it, and even if we could then the atomic operations
945 would fail when interrupted. They are all called as functions and return
946 to the address in LR, so step to there instead. */
947 if (next_pc
> 0xffff0000)
948 next_pc
= get_frame_register_unsigned (frame
, ARM_LR_REGNUM
);
950 arm_insert_single_step_breakpoint (gdbarch
, aspace
, next_pc
);
955 /* Support for displaced stepping of Linux SVC instructions. */
958 arm_linux_cleanup_svc (struct gdbarch
*gdbarch
,
959 struct regcache
*regs
,
960 struct displaced_step_closure
*dsc
)
962 CORE_ADDR from
= dsc
->insn_addr
;
963 ULONGEST apparent_pc
;
966 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &apparent_pc
);
968 within_scratch
= (apparent_pc
>= dsc
->scratch_base
969 && apparent_pc
< (dsc
->scratch_base
970 + DISPLACED_MODIFIED_INSNS
* 4 + 4));
974 fprintf_unfiltered (gdb_stdlog
, "displaced: PC is apparently %.8lx after "
975 "SVC step ", (unsigned long) apparent_pc
);
977 fprintf_unfiltered (gdb_stdlog
, "(within scratch space)\n");
979 fprintf_unfiltered (gdb_stdlog
, "(outside scratch space)\n");
983 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, from
+ 4, BRANCH_WRITE_PC
);
987 arm_linux_copy_svc (struct gdbarch
*gdbarch
, struct regcache
*regs
,
988 struct displaced_step_closure
*dsc
)
990 CORE_ADDR return_to
= 0;
992 struct frame_info
*frame
;
993 unsigned int svc_number
= displaced_read_reg (regs
, dsc
, 7);
994 int is_sigreturn
= 0;
997 frame
= get_current_frame ();
999 is_sigreturn
= arm_linux_sigreturn_return_addr(frame
, svc_number
,
1000 &return_to
, &is_thumb
);
1003 struct symtab_and_line sal
;
1005 if (debug_displaced
)
1006 fprintf_unfiltered (gdb_stdlog
, "displaced: found "
1007 "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
1008 (unsigned long) get_frame_pc (frame
));
1010 if (debug_displaced
)
1011 fprintf_unfiltered (gdb_stdlog
, "displaced: unwind pc = %lx. "
1012 "Setting momentary breakpoint.\n", (unsigned long) return_to
);
1014 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
1017 sal
= find_pc_line (return_to
, 0);
1019 sal
.section
= find_pc_overlay (return_to
);
1020 sal
.explicit_pc
= 1;
1022 frame
= get_prev_frame (frame
);
1026 inferior_thread ()->control
.step_resume_breakpoint
1027 = set_momentary_breakpoint (gdbarch
, sal
, get_frame_id (frame
),
1030 /* set_momentary_breakpoint invalidates FRAME. */
1033 /* We need to make sure we actually insert the momentary
1034 breakpoint set above. */
1035 insert_breakpoints ();
1037 else if (debug_displaced
)
1038 fprintf_unfiltered (gdb_stderr
, "displaced: couldn't find previous "
1039 "frame to set momentary breakpoint for "
1040 "sigreturn/rt_sigreturn\n");
1042 else if (debug_displaced
)
1043 fprintf_unfiltered (gdb_stdlog
, "displaced: sigreturn/rt_sigreturn "
1044 "SVC call not in signal trampoline frame\n");
1047 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1048 location, else nothing.
1049 Insn: unmodified svc.
1050 Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
1051 else leave pc alone. */
1054 dsc
->cleanup
= &arm_linux_cleanup_svc
;
1055 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1057 dsc
->wrote_to_pc
= 1;
1063 /* The following two functions implement single-stepping over calls to Linux
1064 kernel helper routines, which perform e.g. atomic operations on architecture
1065 variants which don't support them natively.
1067 When this function is called, the PC will be pointing at the kernel helper
1068 (at an address inaccessible to GDB), and r14 will point to the return
1069 address. Displaced stepping always executes code in the copy area:
1070 so, make the copy-area instruction branch back to the kernel helper (the
1071 "from" address), and make r14 point to the breakpoint in the copy area. In
1072 that way, we regain control once the kernel helper returns, and can clean
1073 up appropriately (as if we had just returned from the kernel helper as it
1074 would have been called from the non-displaced location). */
1077 cleanup_kernel_helper_return (struct gdbarch
*gdbarch
,
1078 struct regcache
*regs
,
1079 struct displaced_step_closure
*dsc
)
1081 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, dsc
->tmp
[0], CANNOT_WRITE_PC
);
1082 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, dsc
->tmp
[0], BRANCH_WRITE_PC
);
1086 arm_catch_kernel_helper_return (struct gdbarch
*gdbarch
, CORE_ADDR from
,
1087 CORE_ADDR to
, struct regcache
*regs
,
1088 struct displaced_step_closure
*dsc
)
1090 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1093 dsc
->insn_addr
= from
;
1094 dsc
->cleanup
= &cleanup_kernel_helper_return
;
1095 /* Say we wrote to the PC, else cleanup will set PC to the next
1096 instruction in the helper, which isn't helpful. */
1097 dsc
->wrote_to_pc
= 1;
1099 /* Preparation: tmp[0] <- r14
1100 r14 <- <scratch space>+4
1101 *(<scratch space>+8) <- from
1102 Insn: ldr pc, [r14, #4]
1103 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
1105 dsc
->tmp
[0] = displaced_read_reg (regs
, dsc
, ARM_LR_REGNUM
);
1106 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, (ULONGEST
) to
+ 4,
1108 write_memory_unsigned_integer (to
+ 8, 4, byte_order
, from
);
1110 dsc
->modinsn
[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
1113 /* Linux-specific displaced step instruction copying function. Detects when
1114 the program has stepped into a Linux kernel helper routine (which must be
1115 handled as a special case), falling back to arm_displaced_step_copy_insn()
1118 static struct displaced_step_closure
*
1119 arm_linux_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
1120 CORE_ADDR from
, CORE_ADDR to
,
1121 struct regcache
*regs
)
1123 struct displaced_step_closure
*dsc
1124 = xmalloc (sizeof (struct displaced_step_closure
));
1126 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1127 stop at the return location. */
1128 if (from
> 0xffff0000)
1130 if (debug_displaced
)
1131 fprintf_unfiltered (gdb_stdlog
, "displaced: detected kernel helper "
1132 "at %.8lx\n", (unsigned long) from
);
1134 arm_catch_kernel_helper_return (gdbarch
, from
, to
, regs
, dsc
);
1138 /* Override the default handling of SVC instructions. */
1139 dsc
->u
.svc
.copy_svc_os
= arm_linux_copy_svc
;
1141 arm_process_displaced_insn (gdbarch
, from
, to
, regs
, dsc
);
1144 arm_displaced_init_closure (gdbarch
, from
, to
, dsc
);
1149 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1153 arm_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1155 return (*s
== '#' || *s
== '$' || isdigit (*s
) /* Literal number. */
1156 || *s
== '[' /* Register indirection or
1158 || isalpha (*s
)); /* Register value. */
1161 /* This routine is used to parse a special token in ARM's assembly.
1163 The special tokens parsed by it are:
1165 - Register displacement (e.g, [fp, #-8])
1167 It returns one if the special token has been parsed successfully,
1168 or zero if the current token is not considered special. */
1171 arm_stap_parse_special_token (struct gdbarch
*gdbarch
,
1172 struct stap_parse_info
*p
)
1176 /* Temporary holder for lookahead. */
1177 const char *tmp
= p
->arg
;
1179 /* Used to save the register name. */
1190 /* Register name. */
1191 while (isalnum (*tmp
))
1198 regname
= alloca (len
+ 2);
1201 if (isdigit (*start
))
1203 /* If we are dealing with a register whose name begins with a
1204 digit, it means we should prefix the name with the letter
1205 `r', because GDB expects this name pattern. Otherwise (e.g.,
1206 we are dealing with the register `fp'), we don't need to
1207 add such a prefix. */
1212 strncpy (regname
+ offset
, start
, len
);
1214 regname
[len
] = '\0';
1216 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1217 error (_("Invalid register name `%s' on expression `%s'."),
1218 regname
, p
->saved_arg
);
1221 tmp
= skip_spaces_const (tmp
);
1222 if (*tmp
== '#' || *tmp
== '$')
1231 displacement
= strtol (tmp
, &endp
, 10);
1234 /* Skipping last `]'. */
1238 /* The displacement. */
1239 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1240 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
1241 write_exp_elt_longcst (&p
->pstate
, displacement
);
1242 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1244 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
1246 /* The register name. */
1247 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1250 write_exp_string (&p
->pstate
, str
);
1251 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1253 write_exp_elt_opcode (&p
->pstate
, BINOP_ADD
);
1255 /* Casting to the expected type. */
1256 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1257 write_exp_elt_type (&p
->pstate
, lookup_pointer_type (p
->arg_type
));
1258 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1260 write_exp_elt_opcode (&p
->pstate
, UNOP_IND
);
1270 /* ARM process record-replay constructs: syscall, signal etc. */
1272 struct linux_record_tdep arm_linux_record_tdep
;
1274 /* arm_canonicalize_syscall maps from the native arm Linux set
1275 of syscall ids into a canonical set of syscall ids used by
1278 static enum gdb_syscall
1279 arm_canonicalize_syscall (int syscall
)
1281 enum { sys_process_vm_writev
= 377 };
1283 if (syscall
<= gdb_sys_sched_getaffinity
)
1285 else if (syscall
>= 243 && syscall
<= 247)
1287 else if (syscall
>= 248 && syscall
<= 253)
1293 /* Record all registers but PC register for process-record. */
1296 arm_all_but_pc_registers_record (struct regcache
*regcache
)
1300 for (i
= 0; i
< ARM_PC_REGNUM
; i
++)
1302 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
+ i
))
1306 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1312 /* Handler for arm system call instruction recording. */
1315 arm_linux_syscall_record (struct regcache
*regcache
, unsigned long svc_number
)
1318 enum gdb_syscall syscall_gdb
;
1320 syscall_gdb
= arm_canonicalize_syscall (svc_number
);
1322 if (syscall_gdb
< 0)
1324 printf_unfiltered (_("Process record and replay target doesn't "
1325 "support syscall number %s\n"),
1326 plongest (svc_number
));
1330 if (syscall_gdb
== gdb_sys_sigreturn
1331 || syscall_gdb
== gdb_sys_rt_sigreturn
)
1333 if (arm_all_but_pc_registers_record (regcache
))
1338 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1339 &arm_linux_record_tdep
);
1343 /* Record the return value of the system call. */
1344 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
))
1347 if (record_full_arch_list_add_reg (regcache
, ARM_LR_REGNUM
))
1350 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1356 /* Implement the skip_trampoline_code gdbarch method. */
1359 arm_linux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1361 CORE_ADDR target_pc
= arm_skip_stub (frame
, pc
);
1366 return find_solib_trampoline_target (frame
, pc
);
1370 arm_linux_init_abi (struct gdbarch_info info
,
1371 struct gdbarch
*gdbarch
)
1373 static const char *const stap_integer_prefixes
[] = { "#", "$", "", NULL
};
1374 static const char *const stap_register_prefixes
[] = { "r", NULL
};
1375 static const char *const stap_register_indirection_prefixes
[] = { "[",
1377 static const char *const stap_register_indirection_suffixes
[] = { "]",
1379 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1381 linux_init_abi (info
, gdbarch
);
1383 tdep
->lowest_pc
= 0x8000;
1384 if (info
.byte_order
== BFD_ENDIAN_BIG
)
1386 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1387 tdep
->arm_breakpoint
= eabi_linux_arm_be_breakpoint
;
1389 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
1390 tdep
->thumb_breakpoint
= arm_linux_thumb_be_breakpoint
;
1391 tdep
->thumb2_breakpoint
= arm_linux_thumb2_be_breakpoint
;
1395 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1396 tdep
->arm_breakpoint
= eabi_linux_arm_le_breakpoint
;
1398 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
1399 tdep
->thumb_breakpoint
= arm_linux_thumb_le_breakpoint
;
1400 tdep
->thumb2_breakpoint
= arm_linux_thumb2_le_breakpoint
;
1402 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
1403 tdep
->thumb_breakpoint_size
= sizeof (arm_linux_thumb_le_breakpoint
);
1404 tdep
->thumb2_breakpoint_size
= sizeof (arm_linux_thumb2_le_breakpoint
);
1406 if (tdep
->fp_model
== ARM_FLOAT_AUTO
)
1407 tdep
->fp_model
= ARM_FLOAT_FPA
;
1409 switch (tdep
->fp_model
)
1412 tdep
->jb_pc
= ARM_LINUX_JB_PC_FPA
;
1414 case ARM_FLOAT_SOFT_FPA
:
1415 case ARM_FLOAT_SOFT_VFP
:
1417 tdep
->jb_pc
= ARM_LINUX_JB_PC_EABI
;
1421 (__FILE__
, __LINE__
,
1422 _("arm_linux_init_abi: Floating point model not supported"));
1425 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
1427 set_solib_svr4_fetch_link_map_offsets
1428 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1430 /* Single stepping. */
1431 set_gdbarch_software_single_step (gdbarch
, arm_linux_software_single_step
);
1433 /* Shared library handling. */
1434 set_gdbarch_skip_trampoline_code (gdbarch
, arm_linux_skip_trampoline_code
);
1435 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
1437 /* Enable TLS support. */
1438 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1439 svr4_fetch_objfile_link_map
);
1441 tramp_frame_prepend_unwinder (gdbarch
,
1442 &arm_linux_sigreturn_tramp_frame
);
1443 tramp_frame_prepend_unwinder (gdbarch
,
1444 &arm_linux_rt_sigreturn_tramp_frame
);
1445 tramp_frame_prepend_unwinder (gdbarch
,
1446 &arm_eabi_linux_sigreturn_tramp_frame
);
1447 tramp_frame_prepend_unwinder (gdbarch
,
1448 &arm_eabi_linux_rt_sigreturn_tramp_frame
);
1449 tramp_frame_prepend_unwinder (gdbarch
,
1450 &thumb2_eabi_linux_sigreturn_tramp_frame
);
1451 tramp_frame_prepend_unwinder (gdbarch
,
1452 &thumb2_eabi_linux_rt_sigreturn_tramp_frame
);
1453 tramp_frame_prepend_unwinder (gdbarch
,
1454 &arm_linux_restart_syscall_tramp_frame
);
1455 tramp_frame_prepend_unwinder (gdbarch
,
1456 &arm_kernel_linux_restart_syscall_tramp_frame
);
1458 /* Core file support. */
1459 set_gdbarch_regset_from_core_section (gdbarch
,
1460 arm_linux_regset_from_core_section
);
1461 set_gdbarch_core_read_description (gdbarch
, arm_linux_core_read_description
);
1463 if (tdep
->have_vfp_registers
)
1464 set_gdbarch_core_regset_sections (gdbarch
, arm_linux_vfp_regset_sections
);
1465 else if (tdep
->have_fpa_registers
)
1466 set_gdbarch_core_regset_sections (gdbarch
, arm_linux_fpa_regset_sections
);
1468 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
1470 /* Displaced stepping. */
1471 set_gdbarch_displaced_step_copy_insn (gdbarch
,
1472 arm_linux_displaced_step_copy_insn
);
1473 set_gdbarch_displaced_step_fixup (gdbarch
, arm_displaced_step_fixup
);
1474 set_gdbarch_displaced_step_free_closure (gdbarch
,
1475 simple_displaced_step_free_closure
);
1476 set_gdbarch_displaced_step_location (gdbarch
, displaced_step_at_entry_point
);
1478 /* Reversible debugging, process record. */
1479 set_gdbarch_process_record (gdbarch
, arm_process_record
);
1481 /* SystemTap functions. */
1482 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
1483 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
1484 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
1485 stap_register_indirection_prefixes
);
1486 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
1487 stap_register_indirection_suffixes
);
1488 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
1489 set_gdbarch_stap_is_single_operand (gdbarch
, arm_stap_is_single_operand
);
1490 set_gdbarch_stap_parse_special_token (gdbarch
,
1491 arm_stap_parse_special_token
);
1493 tdep
->syscall_next_pc
= arm_linux_syscall_next_pc
;
1495 /* `catch syscall' */
1496 set_xml_syscall_file_name ("syscalls/arm-linux.xml");
1497 set_gdbarch_get_syscall_number (gdbarch
, arm_linux_get_syscall_number
);
1499 /* Syscall record. */
1500 tdep
->arm_syscall_record
= arm_linux_syscall_record
;
1502 /* Initialize the arm_linux_record_tdep. */
1503 /* These values are the size of the type that will be used in a system
1504 call. They are obtained from Linux Kernel source. */
1505 arm_linux_record_tdep
.size_pointer
1506 = gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1507 arm_linux_record_tdep
.size__old_kernel_stat
= 32;
1508 arm_linux_record_tdep
.size_tms
= 16;
1509 arm_linux_record_tdep
.size_loff_t
= 8;
1510 arm_linux_record_tdep
.size_flock
= 16;
1511 arm_linux_record_tdep
.size_oldold_utsname
= 45;
1512 arm_linux_record_tdep
.size_ustat
= 20;
1513 arm_linux_record_tdep
.size_old_sigaction
= 140;
1514 arm_linux_record_tdep
.size_old_sigset_t
= 128;
1515 arm_linux_record_tdep
.size_rlimit
= 8;
1516 arm_linux_record_tdep
.size_rusage
= 72;
1517 arm_linux_record_tdep
.size_timeval
= 8;
1518 arm_linux_record_tdep
.size_timezone
= 8;
1519 arm_linux_record_tdep
.size_old_gid_t
= 2;
1520 arm_linux_record_tdep
.size_old_uid_t
= 2;
1521 arm_linux_record_tdep
.size_fd_set
= 128;
1522 arm_linux_record_tdep
.size_dirent
= 268;
1523 arm_linux_record_tdep
.size_dirent64
= 276;
1524 arm_linux_record_tdep
.size_statfs
= 64;
1525 arm_linux_record_tdep
.size_statfs64
= 84;
1526 arm_linux_record_tdep
.size_sockaddr
= 16;
1527 arm_linux_record_tdep
.size_int
1528 = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
1529 arm_linux_record_tdep
.size_long
1530 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1531 arm_linux_record_tdep
.size_ulong
1532 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1533 arm_linux_record_tdep
.size_msghdr
= 28;
1534 arm_linux_record_tdep
.size_itimerval
= 16;
1535 arm_linux_record_tdep
.size_stat
= 88;
1536 arm_linux_record_tdep
.size_old_utsname
= 325;
1537 arm_linux_record_tdep
.size_sysinfo
= 64;
1538 arm_linux_record_tdep
.size_msqid_ds
= 88;
1539 arm_linux_record_tdep
.size_shmid_ds
= 84;
1540 arm_linux_record_tdep
.size_new_utsname
= 390;
1541 arm_linux_record_tdep
.size_timex
= 128;
1542 arm_linux_record_tdep
.size_mem_dqinfo
= 24;
1543 arm_linux_record_tdep
.size_if_dqblk
= 68;
1544 arm_linux_record_tdep
.size_fs_quota_stat
= 68;
1545 arm_linux_record_tdep
.size_timespec
= 8;
1546 arm_linux_record_tdep
.size_pollfd
= 8;
1547 arm_linux_record_tdep
.size_NFS_FHSIZE
= 32;
1548 arm_linux_record_tdep
.size_knfsd_fh
= 132;
1549 arm_linux_record_tdep
.size_TASK_COMM_LEN
= 16;
1550 arm_linux_record_tdep
.size_sigaction
= 140;
1551 arm_linux_record_tdep
.size_sigset_t
= 8;
1552 arm_linux_record_tdep
.size_siginfo_t
= 128;
1553 arm_linux_record_tdep
.size_cap_user_data_t
= 12;
1554 arm_linux_record_tdep
.size_stack_t
= 12;
1555 arm_linux_record_tdep
.size_off_t
= arm_linux_record_tdep
.size_long
;
1556 arm_linux_record_tdep
.size_stat64
= 96;
1557 arm_linux_record_tdep
.size_gid_t
= 2;
1558 arm_linux_record_tdep
.size_uid_t
= 2;
1559 arm_linux_record_tdep
.size_PAGE_SIZE
= 4096;
1560 arm_linux_record_tdep
.size_flock64
= 24;
1561 arm_linux_record_tdep
.size_user_desc
= 16;
1562 arm_linux_record_tdep
.size_io_event
= 32;
1563 arm_linux_record_tdep
.size_iocb
= 64;
1564 arm_linux_record_tdep
.size_epoll_event
= 12;
1565 arm_linux_record_tdep
.size_itimerspec
1566 = arm_linux_record_tdep
.size_timespec
* 2;
1567 arm_linux_record_tdep
.size_mq_attr
= 32;
1568 arm_linux_record_tdep
.size_siginfo
= 128;
1569 arm_linux_record_tdep
.size_termios
= 36;
1570 arm_linux_record_tdep
.size_termios2
= 44;
1571 arm_linux_record_tdep
.size_pid_t
= 4;
1572 arm_linux_record_tdep
.size_winsize
= 8;
1573 arm_linux_record_tdep
.size_serial_struct
= 60;
1574 arm_linux_record_tdep
.size_serial_icounter_struct
= 80;
1575 arm_linux_record_tdep
.size_hayes_esp_config
= 12;
1576 arm_linux_record_tdep
.size_size_t
= 4;
1577 arm_linux_record_tdep
.size_iovec
= 8;
1579 /* These values are the second argument of system call "sys_ioctl".
1580 They are obtained from Linux Kernel source. */
1581 arm_linux_record_tdep
.ioctl_TCGETS
= 0x5401;
1582 arm_linux_record_tdep
.ioctl_TCSETS
= 0x5402;
1583 arm_linux_record_tdep
.ioctl_TCSETSW
= 0x5403;
1584 arm_linux_record_tdep
.ioctl_TCSETSF
= 0x5404;
1585 arm_linux_record_tdep
.ioctl_TCGETA
= 0x5405;
1586 arm_linux_record_tdep
.ioctl_TCSETA
= 0x5406;
1587 arm_linux_record_tdep
.ioctl_TCSETAW
= 0x5407;
1588 arm_linux_record_tdep
.ioctl_TCSETAF
= 0x5408;
1589 arm_linux_record_tdep
.ioctl_TCSBRK
= 0x5409;
1590 arm_linux_record_tdep
.ioctl_TCXONC
= 0x540a;
1591 arm_linux_record_tdep
.ioctl_TCFLSH
= 0x540b;
1592 arm_linux_record_tdep
.ioctl_TIOCEXCL
= 0x540c;
1593 arm_linux_record_tdep
.ioctl_TIOCNXCL
= 0x540d;
1594 arm_linux_record_tdep
.ioctl_TIOCSCTTY
= 0x540e;
1595 arm_linux_record_tdep
.ioctl_TIOCGPGRP
= 0x540f;
1596 arm_linux_record_tdep
.ioctl_TIOCSPGRP
= 0x5410;
1597 arm_linux_record_tdep
.ioctl_TIOCOUTQ
= 0x5411;
1598 arm_linux_record_tdep
.ioctl_TIOCSTI
= 0x5412;
1599 arm_linux_record_tdep
.ioctl_TIOCGWINSZ
= 0x5413;
1600 arm_linux_record_tdep
.ioctl_TIOCSWINSZ
= 0x5414;
1601 arm_linux_record_tdep
.ioctl_TIOCMGET
= 0x5415;
1602 arm_linux_record_tdep
.ioctl_TIOCMBIS
= 0x5416;
1603 arm_linux_record_tdep
.ioctl_TIOCMBIC
= 0x5417;
1604 arm_linux_record_tdep
.ioctl_TIOCMSET
= 0x5418;
1605 arm_linux_record_tdep
.ioctl_TIOCGSOFTCAR
= 0x5419;
1606 arm_linux_record_tdep
.ioctl_TIOCSSOFTCAR
= 0x541a;
1607 arm_linux_record_tdep
.ioctl_FIONREAD
= 0x541b;
1608 arm_linux_record_tdep
.ioctl_TIOCINQ
= arm_linux_record_tdep
.ioctl_FIONREAD
;
1609 arm_linux_record_tdep
.ioctl_TIOCLINUX
= 0x541c;
1610 arm_linux_record_tdep
.ioctl_TIOCCONS
= 0x541d;
1611 arm_linux_record_tdep
.ioctl_TIOCGSERIAL
= 0x541e;
1612 arm_linux_record_tdep
.ioctl_TIOCSSERIAL
= 0x541f;
1613 arm_linux_record_tdep
.ioctl_TIOCPKT
= 0x5420;
1614 arm_linux_record_tdep
.ioctl_FIONBIO
= 0x5421;
1615 arm_linux_record_tdep
.ioctl_TIOCNOTTY
= 0x5422;
1616 arm_linux_record_tdep
.ioctl_TIOCSETD
= 0x5423;
1617 arm_linux_record_tdep
.ioctl_TIOCGETD
= 0x5424;
1618 arm_linux_record_tdep
.ioctl_TCSBRKP
= 0x5425;
1619 arm_linux_record_tdep
.ioctl_TIOCTTYGSTRUCT
= 0x5426;
1620 arm_linux_record_tdep
.ioctl_TIOCSBRK
= 0x5427;
1621 arm_linux_record_tdep
.ioctl_TIOCCBRK
= 0x5428;
1622 arm_linux_record_tdep
.ioctl_TIOCGSID
= 0x5429;
1623 arm_linux_record_tdep
.ioctl_TCGETS2
= 0x802c542a;
1624 arm_linux_record_tdep
.ioctl_TCSETS2
= 0x402c542b;
1625 arm_linux_record_tdep
.ioctl_TCSETSW2
= 0x402c542c;
1626 arm_linux_record_tdep
.ioctl_TCSETSF2
= 0x402c542d;
1627 arm_linux_record_tdep
.ioctl_TIOCGPTN
= 0x80045430;
1628 arm_linux_record_tdep
.ioctl_TIOCSPTLCK
= 0x40045431;
1629 arm_linux_record_tdep
.ioctl_FIONCLEX
= 0x5450;
1630 arm_linux_record_tdep
.ioctl_FIOCLEX
= 0x5451;
1631 arm_linux_record_tdep
.ioctl_FIOASYNC
= 0x5452;
1632 arm_linux_record_tdep
.ioctl_TIOCSERCONFIG
= 0x5453;
1633 arm_linux_record_tdep
.ioctl_TIOCSERGWILD
= 0x5454;
1634 arm_linux_record_tdep
.ioctl_TIOCSERSWILD
= 0x5455;
1635 arm_linux_record_tdep
.ioctl_TIOCGLCKTRMIOS
= 0x5456;
1636 arm_linux_record_tdep
.ioctl_TIOCSLCKTRMIOS
= 0x5457;
1637 arm_linux_record_tdep
.ioctl_TIOCSERGSTRUCT
= 0x5458;
1638 arm_linux_record_tdep
.ioctl_TIOCSERGETLSR
= 0x5459;
1639 arm_linux_record_tdep
.ioctl_TIOCSERGETMULTI
= 0x545a;
1640 arm_linux_record_tdep
.ioctl_TIOCSERSETMULTI
= 0x545b;
1641 arm_linux_record_tdep
.ioctl_TIOCMIWAIT
= 0x545c;
1642 arm_linux_record_tdep
.ioctl_TIOCGICOUNT
= 0x545d;
1643 arm_linux_record_tdep
.ioctl_TIOCGHAYESESP
= 0x545e;
1644 arm_linux_record_tdep
.ioctl_TIOCSHAYESESP
= 0x545f;
1645 arm_linux_record_tdep
.ioctl_FIOQSIZE
= 0x5460;
1647 /* These values are the second argument of system call "sys_fcntl"
1648 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1649 arm_linux_record_tdep
.fcntl_F_GETLK
= 5;
1650 arm_linux_record_tdep
.fcntl_F_GETLK64
= 12;
1651 arm_linux_record_tdep
.fcntl_F_SETLK64
= 13;
1652 arm_linux_record_tdep
.fcntl_F_SETLKW64
= 14;
1654 arm_linux_record_tdep
.arg1
= ARM_A1_REGNUM
+ 1;
1655 arm_linux_record_tdep
.arg2
= ARM_A1_REGNUM
+ 2;
1656 arm_linux_record_tdep
.arg3
= ARM_A1_REGNUM
+ 3;
1657 arm_linux_record_tdep
.arg4
= ARM_A1_REGNUM
+ 3;
1660 /* Provide a prototype to silence -Wmissing-prototypes. */
1661 extern initialize_file_ftype _initialize_arm_linux_tdep
;
1664 _initialize_arm_linux_tdep (void)
1666 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,
1667 arm_linux_init_abi
);