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"
57 extern int arm_apcs_32
;
59 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
60 is to execute a particular software interrupt, rather than use a
61 particular undefined instruction to provoke a trap. Upon exection
62 of the software interrupt the kernel stops the inferior with a
63 SIGTRAP, and wakes the debugger. */
65 static const gdb_byte arm_linux_arm_le_breakpoint
[] = { 0x01, 0x00, 0x9f, 0xef };
67 static const gdb_byte arm_linux_arm_be_breakpoint
[] = { 0xef, 0x9f, 0x00, 0x01 };
69 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
70 the operand of the swi if old-ABI compatibility is disabled. Therefore,
71 use an undefined instruction instead. This is supported as of kernel
72 version 2.5.70 (May 2003), so should be a safe assumption for EABI
75 static const gdb_byte eabi_linux_arm_le_breakpoint
[] = { 0xf0, 0x01, 0xf0, 0xe7 };
77 static const gdb_byte eabi_linux_arm_be_breakpoint
[] = { 0xe7, 0xf0, 0x01, 0xf0 };
79 /* All the kernels which support Thumb support using a specific undefined
80 instruction for the Thumb breakpoint. */
82 static const gdb_byte arm_linux_thumb_be_breakpoint
[] = {0xde, 0x01};
84 static const gdb_byte arm_linux_thumb_le_breakpoint
[] = {0x01, 0xde};
86 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
87 we must use a length-appropriate breakpoint for 32-bit Thumb
88 instructions. See also thumb_get_next_pc. */
90 static const gdb_byte arm_linux_thumb2_be_breakpoint
[] = { 0xf7, 0xf0, 0xa0, 0x00 };
92 static const gdb_byte arm_linux_thumb2_le_breakpoint
[] = { 0xf0, 0xf7, 0x00, 0xa0 };
94 /* Description of the longjmp buffer. The buffer is treated as an array of
95 elements of size ARM_LINUX_JB_ELEMENT_SIZE.
97 The location of saved registers in this buffer (in particular the PC
98 to use after longjmp is called) varies depending on the ABI (in
99 particular the FP model) and also (possibly) the C Library.
101 For glibc, eglibc, and uclibc the following holds: If the FP model is
102 SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
103 buffer. This is also true for the SoftFPA model. However, for the FPA
104 model the PC is at offset 21 in the buffer. */
105 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
106 #define ARM_LINUX_JB_PC_FPA 21
107 #define ARM_LINUX_JB_PC_EABI 9
110 Dynamic Linking on ARM GNU/Linux
111 --------------------------------
113 Note: PLT = procedure linkage table
114 GOT = global offset table
116 As much as possible, ELF dynamic linking defers the resolution of
117 jump/call addresses until the last minute. The technique used is
118 inspired by the i386 ELF design, and is based on the following
121 1) The calling technique should not force a change in the assembly
122 code produced for apps; it MAY cause changes in the way assembly
123 code is produced for position independent code (i.e. shared
126 2) The technique must be such that all executable areas must not be
127 modified; and any modified areas must not be executed.
129 To do this, there are three steps involved in a typical jump:
133 3) using a pointer from the GOT
135 When the executable or library is first loaded, each GOT entry is
136 initialized to point to the code which implements dynamic name
137 resolution and code finding. This is normally a function in the
138 program interpreter (on ARM GNU/Linux this is usually
139 ld-linux.so.2, but it does not have to be). On the first
140 invocation, the function is located and the GOT entry is replaced
141 with the real function address. Subsequent calls go through steps
142 1, 2 and 3 and end up calling the real code.
149 This is typical ARM code using the 26 bit relative branch or branch
150 and link instructions. The target of the instruction
151 (function_call is usually the address of the function to be called.
152 In position independent code, the target of the instruction is
153 actually an entry in the PLT when calling functions in a shared
154 library. Note that this call is identical to a normal function
155 call, only the target differs.
159 The PLT is a synthetic area, created by the linker. It exists in
160 both executables and libraries. It is an array of stubs, one per
161 imported function call. It looks like this:
164 str lr, [sp, #-4]! @push the return address (lr)
165 ldr lr, [pc, #16] @load from 6 words ahead
166 add lr, pc, lr @form an address for GOT[0]
167 ldr pc, [lr, #8]! @jump to the contents of that addr
169 The return address (lr) is pushed on the stack and used for
170 calculations. The load on the second line loads the lr with
171 &GOT[3] - . - 20. The addition on the third leaves:
173 lr = (&GOT[3] - . - 20) + (. + 8)
177 On the fourth line, the pc and lr are both updated, so that:
183 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
184 "tight", but allows us to keep all the PLT entries the same size.
187 ldr ip, [pc, #4] @load offset from gotoff
188 add ip, pc, ip @add the offset to the pc
189 ldr pc, [ip] @jump to that address
190 gotoff: .word GOT[n+3] - .
192 The load on the first line, gets an offset from the fourth word of
193 the PLT entry. The add on the second line makes ip = &GOT[n+3],
194 which contains either a pointer to PLT[0] (the fixup trampoline) or
195 a pointer to the actual code.
199 The GOT contains helper pointers for both code (PLT) fixups and
200 data fixups. The first 3 entries of the GOT are special. The next
201 M entries (where M is the number of entries in the PLT) belong to
202 the PLT fixups. The next D (all remaining) entries belong to
203 various data fixups. The actual size of the GOT is 3 + M + D.
205 The GOT is also a synthetic area, created by the linker. It exists
206 in both executables and libraries. When the GOT is first
207 initialized , all the GOT entries relating to PLT fixups are
208 pointing to code back at PLT[0].
210 The special entries in the GOT are:
212 GOT[0] = linked list pointer used by the dynamic loader
213 GOT[1] = pointer to the reloc table for this module
214 GOT[2] = pointer to the fixup/resolver code
216 The first invocation of function call comes through and uses the
217 fixup/resolver code. On the entry to the fixup/resolver code:
221 stack[0] = return address (lr) of the function call
222 [r0, r1, r2, r3] are still the arguments to the function call
224 This is enough information for the fixup/resolver code to work
225 with. Before the fixup/resolver code returns, it actually calls
226 the requested function and repairs &GOT[n+3]. */
228 /* The constants below were determined by examining the following files
229 in the linux kernel sources:
231 arch/arm/kernel/signal.c
232 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
233 include/asm-arm/unistd.h
234 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
236 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
237 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
239 /* For ARM EABI, the syscall number is not in the SWI instruction
240 (instead it is loaded into r7). We recognize the pattern that
241 glibc uses... alternatively, we could arrange to do this by
242 function name, but they are not always exported. */
243 #define ARM_SET_R7_SIGRETURN 0xe3a07077
244 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
245 #define ARM_EABI_SYSCALL 0xef000000
247 /* Equivalent patterns for Thumb2. */
248 #define THUMB2_SET_R7_SIGRETURN1 0xf04f
249 #define THUMB2_SET_R7_SIGRETURN2 0x0777
250 #define THUMB2_SET_R7_RT_SIGRETURN1 0xf04f
251 #define THUMB2_SET_R7_RT_SIGRETURN2 0x07ad
252 #define THUMB2_EABI_SYSCALL 0xdf00
254 /* OABI syscall restart trampoline, used for EABI executables too
255 whenever OABI support has been enabled in the kernel. */
256 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
257 #define ARM_LDR_PC_SP_12 0xe49df00c
258 #define ARM_LDR_PC_SP_4 0xe49df004
261 arm_linux_sigtramp_cache (struct frame_info
*this_frame
,
262 struct trad_frame_cache
*this_cache
,
263 CORE_ADDR func
, int regs_offset
)
265 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
266 CORE_ADDR base
= sp
+ regs_offset
;
269 for (i
= 0; i
< 16; i
++)
270 trad_frame_set_reg_addr (this_cache
, i
, base
+ i
* 4);
272 trad_frame_set_reg_addr (this_cache
, ARM_PS_REGNUM
, base
+ 16 * 4);
274 /* The VFP or iWMMXt registers may be saved on the stack, but there's
275 no reliable way to restore them (yet). */
277 /* Save a frame ID. */
278 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
281 /* There are a couple of different possible stack layouts that
284 Before version 2.6.18, the kernel used completely independent
285 layouts for non-RT and RT signals. For non-RT signals the stack
286 began directly with a struct sigcontext. For RT signals the stack
287 began with two redundant pointers (to the siginfo and ucontext),
288 and then the siginfo and ucontext.
290 As of version 2.6.18, the non-RT signal frame layout starts with
291 a ucontext and the RT signal frame starts with a siginfo and then
292 a ucontext. Also, the ucontext now has a designated save area
293 for coprocessor registers.
295 For RT signals, it's easy to tell the difference: we look for
296 pinfo, the pointer to the siginfo. If it has the expected
297 value, we have an old layout. If it doesn't, we have the new
300 For non-RT signals, it's a bit harder. We need something in one
301 layout or the other with a recognizable offset and value. We can't
302 use the return trampoline, because ARM usually uses SA_RESTORER,
303 in which case the stack return trampoline is not filled in.
304 We can't use the saved stack pointer, because sigaltstack might
305 be in use. So for now we guess the new layout... */
307 /* There are three words (trap_no, error_code, oldmask) in
308 struct sigcontext before r0. */
309 #define ARM_SIGCONTEXT_R0 0xc
311 /* There are five words (uc_flags, uc_link, and three for uc_stack)
312 in the ucontext_t before the sigcontext. */
313 #define ARM_UCONTEXT_SIGCONTEXT 0x14
315 /* There are three elements in an rt_sigframe before the ucontext:
316 pinfo, puc, and info. The first two are pointers and the third
317 is a struct siginfo, with size 128 bytes. We could follow puc
318 to the ucontext, but it's simpler to skip the whole thing. */
319 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
320 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
322 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
324 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
327 arm_linux_sigreturn_init (const struct tramp_frame
*self
,
328 struct frame_info
*this_frame
,
329 struct trad_frame_cache
*this_cache
,
332 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
333 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
334 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
335 ULONGEST uc_flags
= read_memory_unsigned_integer (sp
, 4, byte_order
);
337 if (uc_flags
== ARM_NEW_SIGFRAME_MAGIC
)
338 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
339 ARM_UCONTEXT_SIGCONTEXT
340 + ARM_SIGCONTEXT_R0
);
342 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
347 arm_linux_rt_sigreturn_init (const struct tramp_frame
*self
,
348 struct frame_info
*this_frame
,
349 struct trad_frame_cache
*this_cache
,
352 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
353 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
354 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
355 ULONGEST pinfo
= read_memory_unsigned_integer (sp
, 4, byte_order
);
357 if (pinfo
== sp
+ ARM_OLD_RT_SIGFRAME_SIGINFO
)
358 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
359 ARM_OLD_RT_SIGFRAME_UCONTEXT
360 + ARM_UCONTEXT_SIGCONTEXT
361 + ARM_SIGCONTEXT_R0
);
363 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
364 ARM_NEW_RT_SIGFRAME_UCONTEXT
365 + ARM_UCONTEXT_SIGCONTEXT
366 + ARM_SIGCONTEXT_R0
);
370 arm_linux_restart_syscall_init (const struct tramp_frame
*self
,
371 struct frame_info
*this_frame
,
372 struct trad_frame_cache
*this_cache
,
375 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
376 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
377 CORE_ADDR pc
= get_frame_memory_unsigned (this_frame
, sp
, 4);
378 CORE_ADDR cpsr
= get_frame_register_unsigned (this_frame
, ARM_PS_REGNUM
);
379 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
382 /* There are two variants of this trampoline; with older kernels, the
383 stub is placed on the stack, while newer kernels use the stub from
384 the vector page. They are identical except that the older version
385 increments SP by 12 (to skip stored PC and the stub itself), while
386 the newer version increments SP only by 4 (just the stored PC). */
387 if (self
->insn
[1].bytes
== ARM_LDR_PC_SP_4
)
392 /* Update Thumb bit in CPSR. */
398 /* Remove Thumb bit from PC. */
399 pc
= gdbarch_addr_bits_remove (gdbarch
, pc
);
401 /* Save previous register values. */
402 trad_frame_set_reg_value (this_cache
, ARM_SP_REGNUM
, sp
+ sp_offset
);
403 trad_frame_set_reg_value (this_cache
, ARM_PC_REGNUM
, pc
);
404 trad_frame_set_reg_value (this_cache
, ARM_PS_REGNUM
, cpsr
);
406 /* Save a frame ID. */
407 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
410 static struct tramp_frame arm_linux_sigreturn_tramp_frame
= {
414 { ARM_LINUX_SIGRETURN_INSTR
, -1 },
415 { TRAMP_SENTINEL_INSN
}
417 arm_linux_sigreturn_init
420 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame
= {
424 { ARM_LINUX_RT_SIGRETURN_INSTR
, -1 },
425 { TRAMP_SENTINEL_INSN
}
427 arm_linux_rt_sigreturn_init
430 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame
= {
434 { ARM_SET_R7_SIGRETURN
, -1 },
435 { ARM_EABI_SYSCALL
, -1 },
436 { TRAMP_SENTINEL_INSN
}
438 arm_linux_sigreturn_init
441 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame
= {
445 { ARM_SET_R7_RT_SIGRETURN
, -1 },
446 { ARM_EABI_SYSCALL
, -1 },
447 { TRAMP_SENTINEL_INSN
}
449 arm_linux_rt_sigreturn_init
452 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame
= {
456 { THUMB2_SET_R7_SIGRETURN1
, -1 },
457 { THUMB2_SET_R7_SIGRETURN2
, -1 },
458 { THUMB2_EABI_SYSCALL
, -1 },
459 { TRAMP_SENTINEL_INSN
}
461 arm_linux_sigreturn_init
464 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame
= {
468 { THUMB2_SET_R7_RT_SIGRETURN1
, -1 },
469 { THUMB2_SET_R7_RT_SIGRETURN2
, -1 },
470 { THUMB2_EABI_SYSCALL
, -1 },
471 { TRAMP_SENTINEL_INSN
}
473 arm_linux_rt_sigreturn_init
476 static struct tramp_frame arm_linux_restart_syscall_tramp_frame
= {
480 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
481 { ARM_LDR_PC_SP_12
, -1 },
482 { TRAMP_SENTINEL_INSN
}
484 arm_linux_restart_syscall_init
487 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame
= {
491 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
492 { ARM_LDR_PC_SP_4
, -1 },
493 { TRAMP_SENTINEL_INSN
}
495 arm_linux_restart_syscall_init
498 /* Core file and register set support. */
500 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
503 arm_linux_supply_gregset (const struct regset
*regset
,
504 struct regcache
*regcache
,
505 int regnum
, const void *gregs_buf
, size_t len
)
507 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
508 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
509 const gdb_byte
*gregs
= gregs_buf
;
512 gdb_byte pc_buf
[INT_REGISTER_SIZE
];
514 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
515 if (regnum
== -1 || regnum
== regno
)
516 regcache_raw_supply (regcache
, regno
,
517 gregs
+ INT_REGISTER_SIZE
* regno
);
519 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
522 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
523 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
525 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
526 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
529 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
531 reg_pc
= extract_unsigned_integer (gregs
532 + INT_REGISTER_SIZE
* ARM_PC_REGNUM
,
533 INT_REGISTER_SIZE
, byte_order
);
534 reg_pc
= gdbarch_addr_bits_remove (gdbarch
, reg_pc
);
535 store_unsigned_integer (pc_buf
, INT_REGISTER_SIZE
, byte_order
, reg_pc
);
536 regcache_raw_supply (regcache
, ARM_PC_REGNUM
, pc_buf
);
541 arm_linux_collect_gregset (const struct regset
*regset
,
542 const struct regcache
*regcache
,
543 int regnum
, void *gregs_buf
, size_t len
)
545 gdb_byte
*gregs
= gregs_buf
;
548 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
549 if (regnum
== -1 || regnum
== regno
)
550 regcache_raw_collect (regcache
, regno
,
551 gregs
+ INT_REGISTER_SIZE
* regno
);
553 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
556 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
557 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
559 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
560 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
563 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
564 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
565 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
568 /* Support for register format used by the NWFPE FPA emulator. */
570 #define typeNone 0x00
571 #define typeSingle 0x01
572 #define typeDouble 0x02
573 #define typeExtended 0x03
576 supply_nwfpe_register (struct regcache
*regcache
, int regno
,
577 const gdb_byte
*regs
)
579 const gdb_byte
*reg_data
;
581 gdb_byte buf
[FP_REGISTER_SIZE
];
583 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
584 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
585 memset (buf
, 0, FP_REGISTER_SIZE
);
590 memcpy (buf
, reg_data
, 4);
593 memcpy (buf
, reg_data
+ 4, 4);
594 memcpy (buf
+ 4, reg_data
, 4);
597 /* We want sign and exponent, then least significant bits,
598 then most significant. NWFPE does sign, most, least. */
599 memcpy (buf
, reg_data
, 4);
600 memcpy (buf
+ 4, reg_data
+ 8, 4);
601 memcpy (buf
+ 8, reg_data
+ 4, 4);
607 regcache_raw_supply (regcache
, regno
, buf
);
611 collect_nwfpe_register (const struct regcache
*regcache
, int regno
,
616 gdb_byte buf
[FP_REGISTER_SIZE
];
618 regcache_raw_collect (regcache
, regno
, buf
);
620 /* NOTE drow/2006-06-07: This code uses the tag already in the
621 register buffer. I've preserved that when moving the code
622 from the native file to the target file. But this doesn't
623 always make sense. */
625 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
626 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
631 memcpy (reg_data
, buf
, 4);
634 memcpy (reg_data
, buf
+ 4, 4);
635 memcpy (reg_data
+ 4, buf
, 4);
638 memcpy (reg_data
, buf
, 4);
639 memcpy (reg_data
+ 4, buf
+ 8, 4);
640 memcpy (reg_data
+ 8, buf
+ 4, 4);
648 arm_linux_supply_nwfpe (const struct regset
*regset
,
649 struct regcache
*regcache
,
650 int regnum
, const void *regs_buf
, size_t len
)
652 const gdb_byte
*regs
= regs_buf
;
655 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
656 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
657 regs
+ NWFPE_FPSR_OFFSET
);
659 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
660 if (regnum
== -1 || regnum
== regno
)
661 supply_nwfpe_register (regcache
, regno
, regs
);
665 arm_linux_collect_nwfpe (const struct regset
*regset
,
666 const struct regcache
*regcache
,
667 int regnum
, void *regs_buf
, size_t len
)
669 gdb_byte
*regs
= regs_buf
;
672 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
673 if (regnum
== -1 || regnum
== regno
)
674 collect_nwfpe_register (regcache
, regno
, regs
);
676 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
677 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
,
678 regs
+ INT_REGISTER_SIZE
* ARM_FPS_REGNUM
);
681 /* Support VFP register format. */
683 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
686 arm_linux_supply_vfp (const struct regset
*regset
,
687 struct regcache
*regcache
,
688 int regnum
, const void *regs_buf
, size_t len
)
690 const gdb_byte
*regs
= regs_buf
;
693 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
694 regcache_raw_supply (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
696 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
697 if (regnum
== -1 || regnum
== regno
)
698 regcache_raw_supply (regcache
, regno
,
699 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
703 arm_linux_collect_vfp (const struct regset
*regset
,
704 const struct regcache
*regcache
,
705 int regnum
, void *regs_buf
, size_t len
)
707 gdb_byte
*regs
= regs_buf
;
710 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
711 regcache_raw_collect (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
713 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
714 if (regnum
== -1 || regnum
== regno
)
715 regcache_raw_collect (regcache
, regno
,
716 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
719 static const struct regset arm_linux_gregset
=
721 NULL
, arm_linux_supply_gregset
, arm_linux_collect_gregset
724 static const struct regset arm_linux_fpregset
=
726 NULL
, arm_linux_supply_nwfpe
, arm_linux_collect_nwfpe
729 static const struct regset arm_linux_vfpregset
=
731 NULL
, arm_linux_supply_vfp
, arm_linux_collect_vfp
734 /* Return the appropriate register set for the core section identified
735 by SECT_NAME and SECT_SIZE. */
737 static const struct regset
*
738 arm_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
739 const char *sect_name
, size_t sect_size
)
741 if (strcmp (sect_name
, ".reg") == 0
742 && sect_size
== ARM_LINUX_SIZEOF_GREGSET
)
743 return &arm_linux_gregset
;
745 if (strcmp (sect_name
, ".reg2") == 0
746 && sect_size
== ARM_LINUX_SIZEOF_NWFPE
)
747 return &arm_linux_fpregset
;
749 if (strcmp (sect_name
, ".reg-arm-vfp") == 0
750 && sect_size
== ARM_LINUX_SIZEOF_VFP
)
751 return &arm_linux_vfpregset
;
756 /* Core file register set sections. */
758 static struct core_regset_section arm_linux_fpa_regset_sections
[] =
760 { ".reg", ARM_LINUX_SIZEOF_GREGSET
, "general-purpose" },
761 { ".reg2", ARM_LINUX_SIZEOF_NWFPE
, "FPA floating-point" },
765 static struct core_regset_section arm_linux_vfp_regset_sections
[] =
767 { ".reg", ARM_LINUX_SIZEOF_GREGSET
, "general-purpose" },
768 { ".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP
, "VFP floating-point" },
772 /* Determine target description from core file. */
774 static const struct target_desc
*
775 arm_linux_core_read_description (struct gdbarch
*gdbarch
,
776 struct target_ops
*target
,
779 CORE_ADDR arm_hwcap
= 0;
781 if (target_auxv_search (target
, AT_HWCAP
, &arm_hwcap
) != 1)
784 if (arm_hwcap
& HWCAP_VFP
)
786 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
787 Neon with VFPv3-D32. */
788 if (arm_hwcap
& HWCAP_NEON
)
789 return tdesc_arm_with_neon
;
790 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
791 return tdesc_arm_with_vfpv3
;
793 return tdesc_arm_with_vfpv2
;
800 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
801 return 1. In addition, set IS_THUMB depending on whether we
802 will return to ARM or Thumb code. Return 0 if it is not a
803 rt_sigreturn/sigreturn syscall. */
805 arm_linux_sigreturn_return_addr (struct frame_info
*frame
,
806 unsigned long svc_number
,
807 CORE_ADDR
*pc
, int *is_thumb
)
809 /* Is this a sigreturn or rt_sigreturn syscall? */
810 if (svc_number
== 119 || svc_number
== 173)
812 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
814 ULONGEST t_bit
= arm_psr_thumb_bit (frame_unwind_arch (frame
));
816 = frame_unwind_register_unsigned (frame
, ARM_PS_REGNUM
);
818 *is_thumb
= (cpsr
& t_bit
) != 0;
819 *pc
= frame_unwind_caller_pc (frame
);
826 /* At a ptrace syscall-stop, return the syscall number. This either
827 comes from the SWI instruction (OABI) or from r7 (EABI).
829 When the function fails, it should return -1. */
832 arm_linux_get_syscall_number (struct gdbarch
*gdbarch
,
835 struct regcache
*regs
= get_thread_regcache (ptid
);
836 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
840 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
842 ULONGEST svc_number
= -1;
844 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &pc
);
845 regcache_cooked_read_unsigned (regs
, ARM_PS_REGNUM
, &cpsr
);
846 is_thumb
= (cpsr
& t_bit
) != 0;
850 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
854 enum bfd_endian byte_order_for_code
=
855 gdbarch_byte_order_for_code (gdbarch
);
857 /* PC gets incremented before the syscall-stop, so read the
858 previous instruction. */
859 unsigned long this_instr
=
860 read_memory_unsigned_integer (pc
- 4, 4, byte_order_for_code
);
862 unsigned long svc_operand
= (0x00ffffff & this_instr
);
867 svc_number
= svc_operand
- 0x900000;
872 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
879 /* When FRAME is at a syscall instruction, return the PC of the next
880 instruction to be executed. */
883 arm_linux_syscall_next_pc (struct frame_info
*frame
)
885 CORE_ADDR pc
= get_frame_pc (frame
);
886 CORE_ADDR return_addr
= 0;
887 int is_thumb
= arm_frame_is_thumb (frame
);
888 ULONGEST svc_number
= 0;
892 svc_number
= get_frame_register_unsigned (frame
, 7);
893 return_addr
= pc
+ 2;
897 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
898 enum bfd_endian byte_order_for_code
=
899 gdbarch_byte_order_for_code (gdbarch
);
900 unsigned long this_instr
=
901 read_memory_unsigned_integer (pc
, 4, byte_order_for_code
);
903 unsigned long svc_operand
= (0x00ffffff & this_instr
);
904 if (svc_operand
) /* OABI. */
906 svc_number
= svc_operand
- 0x900000;
910 svc_number
= get_frame_register_unsigned (frame
, 7);
913 return_addr
= pc
+ 4;
916 arm_linux_sigreturn_return_addr (frame
, svc_number
, &return_addr
, &is_thumb
);
918 /* Addresses for calling Thumb functions have the bit 0 set. */
926 /* Insert a single step breakpoint at the next executed instruction. */
929 arm_linux_software_single_step (struct frame_info
*frame
)
931 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
932 struct address_space
*aspace
= get_frame_address_space (frame
);
935 if (arm_deal_with_atomic_sequence (frame
))
938 next_pc
= arm_get_next_pc (frame
, get_frame_pc (frame
));
940 /* The Linux kernel offers some user-mode helpers in a high page. We can
941 not read this page (as of 2.6.23), and even if we could then we couldn't
942 set breakpoints in it, and even if we could then the atomic operations
943 would fail when interrupted. They are all called as functions and return
944 to the address in LR, so step to there instead. */
945 if (next_pc
> 0xffff0000)
946 next_pc
= get_frame_register_unsigned (frame
, ARM_LR_REGNUM
);
948 arm_insert_single_step_breakpoint (gdbarch
, aspace
, next_pc
);
953 /* Support for displaced stepping of Linux SVC instructions. */
956 arm_linux_cleanup_svc (struct gdbarch
*gdbarch
,
957 struct regcache
*regs
,
958 struct displaced_step_closure
*dsc
)
960 CORE_ADDR from
= dsc
->insn_addr
;
961 ULONGEST apparent_pc
;
964 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &apparent_pc
);
966 within_scratch
= (apparent_pc
>= dsc
->scratch_base
967 && apparent_pc
< (dsc
->scratch_base
968 + DISPLACED_MODIFIED_INSNS
* 4 + 4));
972 fprintf_unfiltered (gdb_stdlog
, "displaced: PC is apparently %.8lx after "
973 "SVC step ", (unsigned long) apparent_pc
);
975 fprintf_unfiltered (gdb_stdlog
, "(within scratch space)\n");
977 fprintf_unfiltered (gdb_stdlog
, "(outside scratch space)\n");
981 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, from
+ 4, BRANCH_WRITE_PC
);
985 arm_linux_copy_svc (struct gdbarch
*gdbarch
, struct regcache
*regs
,
986 struct displaced_step_closure
*dsc
)
988 CORE_ADDR return_to
= 0;
990 struct frame_info
*frame
;
991 unsigned int svc_number
= displaced_read_reg (regs
, dsc
, 7);
992 int is_sigreturn
= 0;
995 frame
= get_current_frame ();
997 is_sigreturn
= arm_linux_sigreturn_return_addr(frame
, svc_number
,
998 &return_to
, &is_thumb
);
1001 struct symtab_and_line sal
;
1003 if (debug_displaced
)
1004 fprintf_unfiltered (gdb_stdlog
, "displaced: found "
1005 "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
1006 (unsigned long) get_frame_pc (frame
));
1008 if (debug_displaced
)
1009 fprintf_unfiltered (gdb_stdlog
, "displaced: unwind pc = %lx. "
1010 "Setting momentary breakpoint.\n", (unsigned long) return_to
);
1012 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
1015 sal
= find_pc_line (return_to
, 0);
1017 sal
.section
= find_pc_overlay (return_to
);
1018 sal
.explicit_pc
= 1;
1020 frame
= get_prev_frame (frame
);
1024 inferior_thread ()->control
.step_resume_breakpoint
1025 = set_momentary_breakpoint (gdbarch
, sal
, get_frame_id (frame
),
1028 /* set_momentary_breakpoint invalidates FRAME. */
1031 /* We need to make sure we actually insert the momentary
1032 breakpoint set above. */
1033 insert_breakpoints ();
1035 else if (debug_displaced
)
1036 fprintf_unfiltered (gdb_stderr
, "displaced: couldn't find previous "
1037 "frame to set momentary breakpoint for "
1038 "sigreturn/rt_sigreturn\n");
1040 else if (debug_displaced
)
1041 fprintf_unfiltered (gdb_stdlog
, "displaced: sigreturn/rt_sigreturn "
1042 "SVC call not in signal trampoline frame\n");
1045 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1046 location, else nothing.
1047 Insn: unmodified svc.
1048 Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
1049 else leave pc alone. */
1052 dsc
->cleanup
= &arm_linux_cleanup_svc
;
1053 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1055 dsc
->wrote_to_pc
= 1;
1061 /* The following two functions implement single-stepping over calls to Linux
1062 kernel helper routines, which perform e.g. atomic operations on architecture
1063 variants which don't support them natively.
1065 When this function is called, the PC will be pointing at the kernel helper
1066 (at an address inaccessible to GDB), and r14 will point to the return
1067 address. Displaced stepping always executes code in the copy area:
1068 so, make the copy-area instruction branch back to the kernel helper (the
1069 "from" address), and make r14 point to the breakpoint in the copy area. In
1070 that way, we regain control once the kernel helper returns, and can clean
1071 up appropriately (as if we had just returned from the kernel helper as it
1072 would have been called from the non-displaced location). */
1075 cleanup_kernel_helper_return (struct gdbarch
*gdbarch
,
1076 struct regcache
*regs
,
1077 struct displaced_step_closure
*dsc
)
1079 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, dsc
->tmp
[0], CANNOT_WRITE_PC
);
1080 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, dsc
->tmp
[0], BRANCH_WRITE_PC
);
1084 arm_catch_kernel_helper_return (struct gdbarch
*gdbarch
, CORE_ADDR from
,
1085 CORE_ADDR to
, struct regcache
*regs
,
1086 struct displaced_step_closure
*dsc
)
1088 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1091 dsc
->insn_addr
= from
;
1092 dsc
->cleanup
= &cleanup_kernel_helper_return
;
1093 /* Say we wrote to the PC, else cleanup will set PC to the next
1094 instruction in the helper, which isn't helpful. */
1095 dsc
->wrote_to_pc
= 1;
1097 /* Preparation: tmp[0] <- r14
1098 r14 <- <scratch space>+4
1099 *(<scratch space>+8) <- from
1100 Insn: ldr pc, [r14, #4]
1101 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
1103 dsc
->tmp
[0] = displaced_read_reg (regs
, dsc
, ARM_LR_REGNUM
);
1104 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, (ULONGEST
) to
+ 4,
1106 write_memory_unsigned_integer (to
+ 8, 4, byte_order
, from
);
1108 dsc
->modinsn
[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
1111 /* Linux-specific displaced step instruction copying function. Detects when
1112 the program has stepped into a Linux kernel helper routine (which must be
1113 handled as a special case), falling back to arm_displaced_step_copy_insn()
1116 static struct displaced_step_closure
*
1117 arm_linux_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
1118 CORE_ADDR from
, CORE_ADDR to
,
1119 struct regcache
*regs
)
1121 struct displaced_step_closure
*dsc
1122 = xmalloc (sizeof (struct displaced_step_closure
));
1124 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1125 stop at the return location. */
1126 if (from
> 0xffff0000)
1128 if (debug_displaced
)
1129 fprintf_unfiltered (gdb_stdlog
, "displaced: detected kernel helper "
1130 "at %.8lx\n", (unsigned long) from
);
1132 arm_catch_kernel_helper_return (gdbarch
, from
, to
, regs
, dsc
);
1136 /* Override the default handling of SVC instructions. */
1137 dsc
->u
.svc
.copy_svc_os
= arm_linux_copy_svc
;
1139 arm_process_displaced_insn (gdbarch
, from
, to
, regs
, dsc
);
1142 arm_displaced_init_closure (gdbarch
, from
, to
, dsc
);
1147 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1151 arm_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1153 return (*s
== '#' || *s
== '$' || isdigit (*s
) /* Literal number. */
1154 || *s
== '[' /* Register indirection or
1156 || isalpha (*s
)); /* Register value. */
1159 /* This routine is used to parse a special token in ARM's assembly.
1161 The special tokens parsed by it are:
1163 - Register displacement (e.g, [fp, #-8])
1165 It returns one if the special token has been parsed successfully,
1166 or zero if the current token is not considered special. */
1169 arm_stap_parse_special_token (struct gdbarch
*gdbarch
,
1170 struct stap_parse_info
*p
)
1174 /* Temporary holder for lookahead. */
1175 const char *tmp
= p
->arg
;
1177 /* Used to save the register name. */
1188 /* Register name. */
1189 while (isalnum (*tmp
))
1196 regname
= alloca (len
+ 2);
1199 if (isdigit (*start
))
1201 /* If we are dealing with a register whose name begins with a
1202 digit, it means we should prefix the name with the letter
1203 `r', because GDB expects this name pattern. Otherwise (e.g.,
1204 we are dealing with the register `fp'), we don't need to
1205 add such a prefix. */
1210 strncpy (regname
+ offset
, start
, len
);
1212 regname
[len
] = '\0';
1214 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1215 error (_("Invalid register name `%s' on expression `%s'."),
1216 regname
, p
->saved_arg
);
1219 tmp
= skip_spaces_const (tmp
);
1220 if (*tmp
== '#' || *tmp
== '$')
1229 displacement
= strtol (tmp
, &endp
, 10);
1232 /* Skipping last `]'. */
1236 /* The displacement. */
1237 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1238 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
1239 write_exp_elt_longcst (&p
->pstate
, displacement
);
1240 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1242 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
1244 /* The register name. */
1245 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1248 write_exp_string (&p
->pstate
, str
);
1249 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1251 write_exp_elt_opcode (&p
->pstate
, BINOP_ADD
);
1253 /* Casting to the expected type. */
1254 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1255 write_exp_elt_type (&p
->pstate
, lookup_pointer_type (p
->arg_type
));
1256 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1258 write_exp_elt_opcode (&p
->pstate
, UNOP_IND
);
1268 /* ARM process record-replay constructs: syscall, signal etc. */
1270 struct linux_record_tdep arm_linux_record_tdep
;
1272 /* arm_canonicalize_syscall maps from the native arm Linux set
1273 of syscall ids into a canonical set of syscall ids used by
1276 static enum gdb_syscall
1277 arm_canonicalize_syscall (int syscall
)
1279 enum { sys_process_vm_writev
= 377 };
1281 if (syscall
<= gdb_sys_sched_getaffinity
)
1283 else if (syscall
>= 243 && syscall
<= 247)
1285 else if (syscall
>= 248 && syscall
<= 253)
1291 /* Record all registers but PC register for process-record. */
1294 arm_all_but_pc_registers_record (struct regcache
*regcache
)
1298 for (i
= 0; i
< ARM_PC_REGNUM
; i
++)
1300 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
+ i
))
1304 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1310 /* Handler for arm system call instruction recording. */
1313 arm_linux_syscall_record (struct regcache
*regcache
, unsigned long svc_number
)
1316 enum gdb_syscall syscall_gdb
;
1318 syscall_gdb
= arm_canonicalize_syscall (svc_number
);
1320 if (syscall_gdb
< 0)
1322 printf_unfiltered (_("Process record and replay target doesn't "
1323 "support syscall number %s\n"),
1324 plongest (svc_number
));
1328 if (syscall_gdb
== gdb_sys_sigreturn
1329 || syscall_gdb
== gdb_sys_rt_sigreturn
)
1331 if (arm_all_but_pc_registers_record (regcache
))
1336 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1337 &arm_linux_record_tdep
);
1341 /* Record the return value of the system call. */
1342 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
))
1345 if (record_full_arch_list_add_reg (regcache
, ARM_LR_REGNUM
))
1348 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1354 /* Implement the skip_trampoline_code gdbarch method. */
1357 arm_linux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1359 CORE_ADDR target_pc
= arm_skip_stub (frame
, pc
);
1364 return find_solib_trampoline_target (frame
, pc
);
1368 arm_linux_init_abi (struct gdbarch_info info
,
1369 struct gdbarch
*gdbarch
)
1371 static const char *const stap_integer_prefixes
[] = { "#", "$", "", NULL
};
1372 static const char *const stap_register_prefixes
[] = { "r", NULL
};
1373 static const char *const stap_register_indirection_prefixes
[] = { "[",
1375 static const char *const stap_register_indirection_suffixes
[] = { "]",
1377 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1379 linux_init_abi (info
, gdbarch
);
1381 tdep
->lowest_pc
= 0x8000;
1382 if (info
.byte_order
== BFD_ENDIAN_BIG
)
1384 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1385 tdep
->arm_breakpoint
= eabi_linux_arm_be_breakpoint
;
1387 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
1388 tdep
->thumb_breakpoint
= arm_linux_thumb_be_breakpoint
;
1389 tdep
->thumb2_breakpoint
= arm_linux_thumb2_be_breakpoint
;
1393 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1394 tdep
->arm_breakpoint
= eabi_linux_arm_le_breakpoint
;
1396 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
1397 tdep
->thumb_breakpoint
= arm_linux_thumb_le_breakpoint
;
1398 tdep
->thumb2_breakpoint
= arm_linux_thumb2_le_breakpoint
;
1400 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
1401 tdep
->thumb_breakpoint_size
= sizeof (arm_linux_thumb_le_breakpoint
);
1402 tdep
->thumb2_breakpoint_size
= sizeof (arm_linux_thumb2_le_breakpoint
);
1404 if (tdep
->fp_model
== ARM_FLOAT_AUTO
)
1405 tdep
->fp_model
= ARM_FLOAT_FPA
;
1407 switch (tdep
->fp_model
)
1410 tdep
->jb_pc
= ARM_LINUX_JB_PC_FPA
;
1412 case ARM_FLOAT_SOFT_FPA
:
1413 case ARM_FLOAT_SOFT_VFP
:
1415 tdep
->jb_pc
= ARM_LINUX_JB_PC_EABI
;
1419 (__FILE__
, __LINE__
,
1420 _("arm_linux_init_abi: Floating point model not supported"));
1423 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
1425 set_solib_svr4_fetch_link_map_offsets
1426 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1428 /* Single stepping. */
1429 set_gdbarch_software_single_step (gdbarch
, arm_linux_software_single_step
);
1431 /* Shared library handling. */
1432 set_gdbarch_skip_trampoline_code (gdbarch
, arm_linux_skip_trampoline_code
);
1433 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
1435 /* Enable TLS support. */
1436 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1437 svr4_fetch_objfile_link_map
);
1439 tramp_frame_prepend_unwinder (gdbarch
,
1440 &arm_linux_sigreturn_tramp_frame
);
1441 tramp_frame_prepend_unwinder (gdbarch
,
1442 &arm_linux_rt_sigreturn_tramp_frame
);
1443 tramp_frame_prepend_unwinder (gdbarch
,
1444 &arm_eabi_linux_sigreturn_tramp_frame
);
1445 tramp_frame_prepend_unwinder (gdbarch
,
1446 &arm_eabi_linux_rt_sigreturn_tramp_frame
);
1447 tramp_frame_prepend_unwinder (gdbarch
,
1448 &thumb2_eabi_linux_sigreturn_tramp_frame
);
1449 tramp_frame_prepend_unwinder (gdbarch
,
1450 &thumb2_eabi_linux_rt_sigreturn_tramp_frame
);
1451 tramp_frame_prepend_unwinder (gdbarch
,
1452 &arm_linux_restart_syscall_tramp_frame
);
1453 tramp_frame_prepend_unwinder (gdbarch
,
1454 &arm_kernel_linux_restart_syscall_tramp_frame
);
1456 /* Core file support. */
1457 set_gdbarch_regset_from_core_section (gdbarch
,
1458 arm_linux_regset_from_core_section
);
1459 set_gdbarch_core_read_description (gdbarch
, arm_linux_core_read_description
);
1461 if (tdep
->have_vfp_registers
)
1462 set_gdbarch_core_regset_sections (gdbarch
, arm_linux_vfp_regset_sections
);
1463 else if (tdep
->have_fpa_registers
)
1464 set_gdbarch_core_regset_sections (gdbarch
, arm_linux_fpa_regset_sections
);
1466 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
1468 /* Displaced stepping. */
1469 set_gdbarch_displaced_step_copy_insn (gdbarch
,
1470 arm_linux_displaced_step_copy_insn
);
1471 set_gdbarch_displaced_step_fixup (gdbarch
, arm_displaced_step_fixup
);
1472 set_gdbarch_displaced_step_free_closure (gdbarch
,
1473 simple_displaced_step_free_closure
);
1474 set_gdbarch_displaced_step_location (gdbarch
, displaced_step_at_entry_point
);
1476 /* Reversible debugging, process record. */
1477 set_gdbarch_process_record (gdbarch
, arm_process_record
);
1479 /* SystemTap functions. */
1480 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
1481 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
1482 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
1483 stap_register_indirection_prefixes
);
1484 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
1485 stap_register_indirection_suffixes
);
1486 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
1487 set_gdbarch_stap_is_single_operand (gdbarch
, arm_stap_is_single_operand
);
1488 set_gdbarch_stap_parse_special_token (gdbarch
,
1489 arm_stap_parse_special_token
);
1491 tdep
->syscall_next_pc
= arm_linux_syscall_next_pc
;
1493 /* `catch syscall' */
1494 set_xml_syscall_file_name ("syscalls/arm-linux.xml");
1495 set_gdbarch_get_syscall_number (gdbarch
, arm_linux_get_syscall_number
);
1497 /* Syscall record. */
1498 tdep
->arm_syscall_record
= arm_linux_syscall_record
;
1500 /* Initialize the arm_linux_record_tdep. */
1501 /* These values are the size of the type that will be used in a system
1502 call. They are obtained from Linux Kernel source. */
1503 arm_linux_record_tdep
.size_pointer
1504 = gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1505 arm_linux_record_tdep
.size__old_kernel_stat
= 32;
1506 arm_linux_record_tdep
.size_tms
= 16;
1507 arm_linux_record_tdep
.size_loff_t
= 8;
1508 arm_linux_record_tdep
.size_flock
= 16;
1509 arm_linux_record_tdep
.size_oldold_utsname
= 45;
1510 arm_linux_record_tdep
.size_ustat
= 20;
1511 arm_linux_record_tdep
.size_old_sigaction
= 140;
1512 arm_linux_record_tdep
.size_old_sigset_t
= 128;
1513 arm_linux_record_tdep
.size_rlimit
= 8;
1514 arm_linux_record_tdep
.size_rusage
= 72;
1515 arm_linux_record_tdep
.size_timeval
= 8;
1516 arm_linux_record_tdep
.size_timezone
= 8;
1517 arm_linux_record_tdep
.size_old_gid_t
= 2;
1518 arm_linux_record_tdep
.size_old_uid_t
= 2;
1519 arm_linux_record_tdep
.size_fd_set
= 128;
1520 arm_linux_record_tdep
.size_dirent
= 268;
1521 arm_linux_record_tdep
.size_dirent64
= 276;
1522 arm_linux_record_tdep
.size_statfs
= 64;
1523 arm_linux_record_tdep
.size_statfs64
= 84;
1524 arm_linux_record_tdep
.size_sockaddr
= 16;
1525 arm_linux_record_tdep
.size_int
1526 = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
1527 arm_linux_record_tdep
.size_long
1528 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1529 arm_linux_record_tdep
.size_ulong
1530 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1531 arm_linux_record_tdep
.size_msghdr
= 28;
1532 arm_linux_record_tdep
.size_itimerval
= 16;
1533 arm_linux_record_tdep
.size_stat
= 88;
1534 arm_linux_record_tdep
.size_old_utsname
= 325;
1535 arm_linux_record_tdep
.size_sysinfo
= 64;
1536 arm_linux_record_tdep
.size_msqid_ds
= 88;
1537 arm_linux_record_tdep
.size_shmid_ds
= 84;
1538 arm_linux_record_tdep
.size_new_utsname
= 390;
1539 arm_linux_record_tdep
.size_timex
= 128;
1540 arm_linux_record_tdep
.size_mem_dqinfo
= 24;
1541 arm_linux_record_tdep
.size_if_dqblk
= 68;
1542 arm_linux_record_tdep
.size_fs_quota_stat
= 68;
1543 arm_linux_record_tdep
.size_timespec
= 8;
1544 arm_linux_record_tdep
.size_pollfd
= 8;
1545 arm_linux_record_tdep
.size_NFS_FHSIZE
= 32;
1546 arm_linux_record_tdep
.size_knfsd_fh
= 132;
1547 arm_linux_record_tdep
.size_TASK_COMM_LEN
= 16;
1548 arm_linux_record_tdep
.size_sigaction
= 140;
1549 arm_linux_record_tdep
.size_sigset_t
= 8;
1550 arm_linux_record_tdep
.size_siginfo_t
= 128;
1551 arm_linux_record_tdep
.size_cap_user_data_t
= 12;
1552 arm_linux_record_tdep
.size_stack_t
= 12;
1553 arm_linux_record_tdep
.size_off_t
= arm_linux_record_tdep
.size_long
;
1554 arm_linux_record_tdep
.size_stat64
= 96;
1555 arm_linux_record_tdep
.size_gid_t
= 2;
1556 arm_linux_record_tdep
.size_uid_t
= 2;
1557 arm_linux_record_tdep
.size_PAGE_SIZE
= 4096;
1558 arm_linux_record_tdep
.size_flock64
= 24;
1559 arm_linux_record_tdep
.size_user_desc
= 16;
1560 arm_linux_record_tdep
.size_io_event
= 32;
1561 arm_linux_record_tdep
.size_iocb
= 64;
1562 arm_linux_record_tdep
.size_epoll_event
= 12;
1563 arm_linux_record_tdep
.size_itimerspec
1564 = arm_linux_record_tdep
.size_timespec
* 2;
1565 arm_linux_record_tdep
.size_mq_attr
= 32;
1566 arm_linux_record_tdep
.size_siginfo
= 128;
1567 arm_linux_record_tdep
.size_termios
= 36;
1568 arm_linux_record_tdep
.size_termios2
= 44;
1569 arm_linux_record_tdep
.size_pid_t
= 4;
1570 arm_linux_record_tdep
.size_winsize
= 8;
1571 arm_linux_record_tdep
.size_serial_struct
= 60;
1572 arm_linux_record_tdep
.size_serial_icounter_struct
= 80;
1573 arm_linux_record_tdep
.size_hayes_esp_config
= 12;
1574 arm_linux_record_tdep
.size_size_t
= 4;
1575 arm_linux_record_tdep
.size_iovec
= 8;
1577 /* These values are the second argument of system call "sys_ioctl".
1578 They are obtained from Linux Kernel source. */
1579 arm_linux_record_tdep
.ioctl_TCGETS
= 0x5401;
1580 arm_linux_record_tdep
.ioctl_TCSETS
= 0x5402;
1581 arm_linux_record_tdep
.ioctl_TCSETSW
= 0x5403;
1582 arm_linux_record_tdep
.ioctl_TCSETSF
= 0x5404;
1583 arm_linux_record_tdep
.ioctl_TCGETA
= 0x5405;
1584 arm_linux_record_tdep
.ioctl_TCSETA
= 0x5406;
1585 arm_linux_record_tdep
.ioctl_TCSETAW
= 0x5407;
1586 arm_linux_record_tdep
.ioctl_TCSETAF
= 0x5408;
1587 arm_linux_record_tdep
.ioctl_TCSBRK
= 0x5409;
1588 arm_linux_record_tdep
.ioctl_TCXONC
= 0x540a;
1589 arm_linux_record_tdep
.ioctl_TCFLSH
= 0x540b;
1590 arm_linux_record_tdep
.ioctl_TIOCEXCL
= 0x540c;
1591 arm_linux_record_tdep
.ioctl_TIOCNXCL
= 0x540d;
1592 arm_linux_record_tdep
.ioctl_TIOCSCTTY
= 0x540e;
1593 arm_linux_record_tdep
.ioctl_TIOCGPGRP
= 0x540f;
1594 arm_linux_record_tdep
.ioctl_TIOCSPGRP
= 0x5410;
1595 arm_linux_record_tdep
.ioctl_TIOCOUTQ
= 0x5411;
1596 arm_linux_record_tdep
.ioctl_TIOCSTI
= 0x5412;
1597 arm_linux_record_tdep
.ioctl_TIOCGWINSZ
= 0x5413;
1598 arm_linux_record_tdep
.ioctl_TIOCSWINSZ
= 0x5414;
1599 arm_linux_record_tdep
.ioctl_TIOCMGET
= 0x5415;
1600 arm_linux_record_tdep
.ioctl_TIOCMBIS
= 0x5416;
1601 arm_linux_record_tdep
.ioctl_TIOCMBIC
= 0x5417;
1602 arm_linux_record_tdep
.ioctl_TIOCMSET
= 0x5418;
1603 arm_linux_record_tdep
.ioctl_TIOCGSOFTCAR
= 0x5419;
1604 arm_linux_record_tdep
.ioctl_TIOCSSOFTCAR
= 0x541a;
1605 arm_linux_record_tdep
.ioctl_FIONREAD
= 0x541b;
1606 arm_linux_record_tdep
.ioctl_TIOCINQ
= arm_linux_record_tdep
.ioctl_FIONREAD
;
1607 arm_linux_record_tdep
.ioctl_TIOCLINUX
= 0x541c;
1608 arm_linux_record_tdep
.ioctl_TIOCCONS
= 0x541d;
1609 arm_linux_record_tdep
.ioctl_TIOCGSERIAL
= 0x541e;
1610 arm_linux_record_tdep
.ioctl_TIOCSSERIAL
= 0x541f;
1611 arm_linux_record_tdep
.ioctl_TIOCPKT
= 0x5420;
1612 arm_linux_record_tdep
.ioctl_FIONBIO
= 0x5421;
1613 arm_linux_record_tdep
.ioctl_TIOCNOTTY
= 0x5422;
1614 arm_linux_record_tdep
.ioctl_TIOCSETD
= 0x5423;
1615 arm_linux_record_tdep
.ioctl_TIOCGETD
= 0x5424;
1616 arm_linux_record_tdep
.ioctl_TCSBRKP
= 0x5425;
1617 arm_linux_record_tdep
.ioctl_TIOCTTYGSTRUCT
= 0x5426;
1618 arm_linux_record_tdep
.ioctl_TIOCSBRK
= 0x5427;
1619 arm_linux_record_tdep
.ioctl_TIOCCBRK
= 0x5428;
1620 arm_linux_record_tdep
.ioctl_TIOCGSID
= 0x5429;
1621 arm_linux_record_tdep
.ioctl_TCGETS2
= 0x802c542a;
1622 arm_linux_record_tdep
.ioctl_TCSETS2
= 0x402c542b;
1623 arm_linux_record_tdep
.ioctl_TCSETSW2
= 0x402c542c;
1624 arm_linux_record_tdep
.ioctl_TCSETSF2
= 0x402c542d;
1625 arm_linux_record_tdep
.ioctl_TIOCGPTN
= 0x80045430;
1626 arm_linux_record_tdep
.ioctl_TIOCSPTLCK
= 0x40045431;
1627 arm_linux_record_tdep
.ioctl_FIONCLEX
= 0x5450;
1628 arm_linux_record_tdep
.ioctl_FIOCLEX
= 0x5451;
1629 arm_linux_record_tdep
.ioctl_FIOASYNC
= 0x5452;
1630 arm_linux_record_tdep
.ioctl_TIOCSERCONFIG
= 0x5453;
1631 arm_linux_record_tdep
.ioctl_TIOCSERGWILD
= 0x5454;
1632 arm_linux_record_tdep
.ioctl_TIOCSERSWILD
= 0x5455;
1633 arm_linux_record_tdep
.ioctl_TIOCGLCKTRMIOS
= 0x5456;
1634 arm_linux_record_tdep
.ioctl_TIOCSLCKTRMIOS
= 0x5457;
1635 arm_linux_record_tdep
.ioctl_TIOCSERGSTRUCT
= 0x5458;
1636 arm_linux_record_tdep
.ioctl_TIOCSERGETLSR
= 0x5459;
1637 arm_linux_record_tdep
.ioctl_TIOCSERGETMULTI
= 0x545a;
1638 arm_linux_record_tdep
.ioctl_TIOCSERSETMULTI
= 0x545b;
1639 arm_linux_record_tdep
.ioctl_TIOCMIWAIT
= 0x545c;
1640 arm_linux_record_tdep
.ioctl_TIOCGICOUNT
= 0x545d;
1641 arm_linux_record_tdep
.ioctl_TIOCGHAYESESP
= 0x545e;
1642 arm_linux_record_tdep
.ioctl_TIOCSHAYESESP
= 0x545f;
1643 arm_linux_record_tdep
.ioctl_FIOQSIZE
= 0x5460;
1645 /* These values are the second argument of system call "sys_fcntl"
1646 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1647 arm_linux_record_tdep
.fcntl_F_GETLK
= 5;
1648 arm_linux_record_tdep
.fcntl_F_GETLK64
= 12;
1649 arm_linux_record_tdep
.fcntl_F_SETLK64
= 13;
1650 arm_linux_record_tdep
.fcntl_F_SETLKW64
= 14;
1652 arm_linux_record_tdep
.arg1
= ARM_A1_REGNUM
+ 1;
1653 arm_linux_record_tdep
.arg2
= ARM_A1_REGNUM
+ 2;
1654 arm_linux_record_tdep
.arg3
= ARM_A1_REGNUM
+ 3;
1655 arm_linux_record_tdep
.arg4
= ARM_A1_REGNUM
+ 3;
1658 /* Provide a prototype to silence -Wmissing-prototypes. */
1659 extern initialize_file_ftype _initialize_arm_linux_tdep
;
1662 _initialize_arm_linux_tdep (void)
1664 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,
1665 arm_linux_init_abi
);