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"
44 #include "gdbthread.h"
47 #include "record-full.h"
48 #include "linux-record.h"
50 #include "cli/cli-utils.h"
51 #include "stap-probe.h"
52 #include "parser-defs.h"
53 #include "user-regs.h"
55 #include "elf/common.h"
58 extern int arm_apcs_32
;
60 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
61 is to execute a particular software interrupt, rather than use a
62 particular undefined instruction to provoke a trap. Upon exection
63 of the software interrupt the kernel stops the inferior with a
64 SIGTRAP, and wakes the debugger. */
66 static const gdb_byte arm_linux_arm_le_breakpoint
[] = { 0x01, 0x00, 0x9f, 0xef };
68 static const gdb_byte arm_linux_arm_be_breakpoint
[] = { 0xef, 0x9f, 0x00, 0x01 };
70 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
71 the operand of the swi if old-ABI compatibility is disabled. Therefore,
72 use an undefined instruction instead. This is supported as of kernel
73 version 2.5.70 (May 2003), so should be a safe assumption for EABI
76 static const gdb_byte eabi_linux_arm_le_breakpoint
[] = { 0xf0, 0x01, 0xf0, 0xe7 };
78 static const gdb_byte eabi_linux_arm_be_breakpoint
[] = { 0xe7, 0xf0, 0x01, 0xf0 };
80 /* All the kernels which support Thumb support using a specific undefined
81 instruction for the Thumb breakpoint. */
83 static const gdb_byte arm_linux_thumb_be_breakpoint
[] = {0xde, 0x01};
85 static const gdb_byte arm_linux_thumb_le_breakpoint
[] = {0x01, 0xde};
87 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
88 we must use a length-appropriate breakpoint for 32-bit Thumb
89 instructions. See also thumb_get_next_pc. */
91 static const gdb_byte arm_linux_thumb2_be_breakpoint
[] = { 0xf7, 0xf0, 0xa0, 0x00 };
93 static const gdb_byte arm_linux_thumb2_le_breakpoint
[] = { 0xf0, 0xf7, 0x00, 0xa0 };
95 /* Description of the longjmp buffer. The buffer is treated as an array of
96 elements of size ARM_LINUX_JB_ELEMENT_SIZE.
98 The location of saved registers in this buffer (in particular the PC
99 to use after longjmp is called) varies depending on the ABI (in
100 particular the FP model) and also (possibly) the C Library.
102 For glibc, eglibc, and uclibc the following holds: If the FP model is
103 SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
104 buffer. This is also true for the SoftFPA model. However, for the FPA
105 model the PC is at offset 21 in the buffer. */
106 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
107 #define ARM_LINUX_JB_PC_FPA 21
108 #define ARM_LINUX_JB_PC_EABI 9
111 Dynamic Linking on ARM GNU/Linux
112 --------------------------------
114 Note: PLT = procedure linkage table
115 GOT = global offset table
117 As much as possible, ELF dynamic linking defers the resolution of
118 jump/call addresses until the last minute. The technique used is
119 inspired by the i386 ELF design, and is based on the following
122 1) The calling technique should not force a change in the assembly
123 code produced for apps; it MAY cause changes in the way assembly
124 code is produced for position independent code (i.e. shared
127 2) The technique must be such that all executable areas must not be
128 modified; and any modified areas must not be executed.
130 To do this, there are three steps involved in a typical jump:
134 3) using a pointer from the GOT
136 When the executable or library is first loaded, each GOT entry is
137 initialized to point to the code which implements dynamic name
138 resolution and code finding. This is normally a function in the
139 program interpreter (on ARM GNU/Linux this is usually
140 ld-linux.so.2, but it does not have to be). On the first
141 invocation, the function is located and the GOT entry is replaced
142 with the real function address. Subsequent calls go through steps
143 1, 2 and 3 and end up calling the real code.
150 This is typical ARM code using the 26 bit relative branch or branch
151 and link instructions. The target of the instruction
152 (function_call is usually the address of the function to be called.
153 In position independent code, the target of the instruction is
154 actually an entry in the PLT when calling functions in a shared
155 library. Note that this call is identical to a normal function
156 call, only the target differs.
160 The PLT is a synthetic area, created by the linker. It exists in
161 both executables and libraries. It is an array of stubs, one per
162 imported function call. It looks like this:
165 str lr, [sp, #-4]! @push the return address (lr)
166 ldr lr, [pc, #16] @load from 6 words ahead
167 add lr, pc, lr @form an address for GOT[0]
168 ldr pc, [lr, #8]! @jump to the contents of that addr
170 The return address (lr) is pushed on the stack and used for
171 calculations. The load on the second line loads the lr with
172 &GOT[3] - . - 20. The addition on the third leaves:
174 lr = (&GOT[3] - . - 20) + (. + 8)
178 On the fourth line, the pc and lr are both updated, so that:
184 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
185 "tight", but allows us to keep all the PLT entries the same size.
188 ldr ip, [pc, #4] @load offset from gotoff
189 add ip, pc, ip @add the offset to the pc
190 ldr pc, [ip] @jump to that address
191 gotoff: .word GOT[n+3] - .
193 The load on the first line, gets an offset from the fourth word of
194 the PLT entry. The add on the second line makes ip = &GOT[n+3],
195 which contains either a pointer to PLT[0] (the fixup trampoline) or
196 a pointer to the actual code.
200 The GOT contains helper pointers for both code (PLT) fixups and
201 data fixups. The first 3 entries of the GOT are special. The next
202 M entries (where M is the number of entries in the PLT) belong to
203 the PLT fixups. The next D (all remaining) entries belong to
204 various data fixups. The actual size of the GOT is 3 + M + D.
206 The GOT is also a synthetic area, created by the linker. It exists
207 in both executables and libraries. When the GOT is first
208 initialized , all the GOT entries relating to PLT fixups are
209 pointing to code back at PLT[0].
211 The special entries in the GOT are:
213 GOT[0] = linked list pointer used by the dynamic loader
214 GOT[1] = pointer to the reloc table for this module
215 GOT[2] = pointer to the fixup/resolver code
217 The first invocation of function call comes through and uses the
218 fixup/resolver code. On the entry to the fixup/resolver code:
222 stack[0] = return address (lr) of the function call
223 [r0, r1, r2, r3] are still the arguments to the function call
225 This is enough information for the fixup/resolver code to work
226 with. Before the fixup/resolver code returns, it actually calls
227 the requested function and repairs &GOT[n+3]. */
229 /* The constants below were determined by examining the following files
230 in the linux kernel sources:
232 arch/arm/kernel/signal.c
233 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
234 include/asm-arm/unistd.h
235 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
237 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
238 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
240 /* For ARM EABI, the syscall number is not in the SWI instruction
241 (instead it is loaded into r7). We recognize the pattern that
242 glibc uses... alternatively, we could arrange to do this by
243 function name, but they are not always exported. */
244 #define ARM_SET_R7_SIGRETURN 0xe3a07077
245 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
246 #define ARM_EABI_SYSCALL 0xef000000
248 /* OABI syscall restart trampoline, used for EABI executables too
249 whenever OABI support has been enabled in the kernel. */
250 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
251 #define ARM_LDR_PC_SP_12 0xe49df00c
252 #define ARM_LDR_PC_SP_4 0xe49df004
255 arm_linux_sigtramp_cache (struct frame_info
*this_frame
,
256 struct trad_frame_cache
*this_cache
,
257 CORE_ADDR func
, int regs_offset
)
259 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
260 CORE_ADDR base
= sp
+ regs_offset
;
263 for (i
= 0; i
< 16; i
++)
264 trad_frame_set_reg_addr (this_cache
, i
, base
+ i
* 4);
266 trad_frame_set_reg_addr (this_cache
, ARM_PS_REGNUM
, base
+ 16 * 4);
268 /* The VFP or iWMMXt registers may be saved on the stack, but there's
269 no reliable way to restore them (yet). */
271 /* Save a frame ID. */
272 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
275 /* There are a couple of different possible stack layouts that
278 Before version 2.6.18, the kernel used completely independent
279 layouts for non-RT and RT signals. For non-RT signals the stack
280 began directly with a struct sigcontext. For RT signals the stack
281 began with two redundant pointers (to the siginfo and ucontext),
282 and then the siginfo and ucontext.
284 As of version 2.6.18, the non-RT signal frame layout starts with
285 a ucontext and the RT signal frame starts with a siginfo and then
286 a ucontext. Also, the ucontext now has a designated save area
287 for coprocessor registers.
289 For RT signals, it's easy to tell the difference: we look for
290 pinfo, the pointer to the siginfo. If it has the expected
291 value, we have an old layout. If it doesn't, we have the new
294 For non-RT signals, it's a bit harder. We need something in one
295 layout or the other with a recognizable offset and value. We can't
296 use the return trampoline, because ARM usually uses SA_RESTORER,
297 in which case the stack return trampoline is not filled in.
298 We can't use the saved stack pointer, because sigaltstack might
299 be in use. So for now we guess the new layout... */
301 /* There are three words (trap_no, error_code, oldmask) in
302 struct sigcontext before r0. */
303 #define ARM_SIGCONTEXT_R0 0xc
305 /* There are five words (uc_flags, uc_link, and three for uc_stack)
306 in the ucontext_t before the sigcontext. */
307 #define ARM_UCONTEXT_SIGCONTEXT 0x14
309 /* There are three elements in an rt_sigframe before the ucontext:
310 pinfo, puc, and info. The first two are pointers and the third
311 is a struct siginfo, with size 128 bytes. We could follow puc
312 to the ucontext, but it's simpler to skip the whole thing. */
313 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
314 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
316 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
318 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
321 arm_linux_sigreturn_init (const struct tramp_frame
*self
,
322 struct frame_info
*this_frame
,
323 struct trad_frame_cache
*this_cache
,
326 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
327 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
328 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
329 ULONGEST uc_flags
= read_memory_unsigned_integer (sp
, 4, byte_order
);
331 if (uc_flags
== ARM_NEW_SIGFRAME_MAGIC
)
332 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
333 ARM_UCONTEXT_SIGCONTEXT
334 + ARM_SIGCONTEXT_R0
);
336 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
341 arm_linux_rt_sigreturn_init (const struct tramp_frame
*self
,
342 struct frame_info
*this_frame
,
343 struct trad_frame_cache
*this_cache
,
346 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
347 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
348 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
349 ULONGEST pinfo
= read_memory_unsigned_integer (sp
, 4, byte_order
);
351 if (pinfo
== sp
+ ARM_OLD_RT_SIGFRAME_SIGINFO
)
352 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
353 ARM_OLD_RT_SIGFRAME_UCONTEXT
354 + ARM_UCONTEXT_SIGCONTEXT
355 + ARM_SIGCONTEXT_R0
);
357 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
358 ARM_NEW_RT_SIGFRAME_UCONTEXT
359 + ARM_UCONTEXT_SIGCONTEXT
360 + ARM_SIGCONTEXT_R0
);
364 arm_linux_restart_syscall_init (const struct tramp_frame
*self
,
365 struct frame_info
*this_frame
,
366 struct trad_frame_cache
*this_cache
,
369 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
370 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
371 CORE_ADDR pc
= get_frame_memory_unsigned (this_frame
, sp
, 4);
372 CORE_ADDR cpsr
= get_frame_register_unsigned (this_frame
, ARM_PS_REGNUM
);
373 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
376 /* There are two variants of this trampoline; with older kernels, the
377 stub is placed on the stack, while newer kernels use the stub from
378 the vector page. They are identical except that the older version
379 increments SP by 12 (to skip stored PC and the stub itself), while
380 the newer version increments SP only by 4 (just the stored PC). */
381 if (self
->insn
[1].bytes
== ARM_LDR_PC_SP_4
)
386 /* Update Thumb bit in CPSR. */
392 /* Remove Thumb bit from PC. */
393 pc
= gdbarch_addr_bits_remove (gdbarch
, pc
);
395 /* Save previous register values. */
396 trad_frame_set_reg_value (this_cache
, ARM_SP_REGNUM
, sp
+ sp_offset
);
397 trad_frame_set_reg_value (this_cache
, ARM_PC_REGNUM
, pc
);
398 trad_frame_set_reg_value (this_cache
, ARM_PS_REGNUM
, cpsr
);
400 /* Save a frame ID. */
401 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
404 static struct tramp_frame arm_linux_sigreturn_tramp_frame
= {
408 { ARM_LINUX_SIGRETURN_INSTR
, -1 },
409 { TRAMP_SENTINEL_INSN
}
411 arm_linux_sigreturn_init
414 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame
= {
418 { ARM_LINUX_RT_SIGRETURN_INSTR
, -1 },
419 { TRAMP_SENTINEL_INSN
}
421 arm_linux_rt_sigreturn_init
424 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame
= {
428 { ARM_SET_R7_SIGRETURN
, -1 },
429 { ARM_EABI_SYSCALL
, -1 },
430 { TRAMP_SENTINEL_INSN
}
432 arm_linux_sigreturn_init
435 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame
= {
439 { ARM_SET_R7_RT_SIGRETURN
, -1 },
440 { ARM_EABI_SYSCALL
, -1 },
441 { TRAMP_SENTINEL_INSN
}
443 arm_linux_rt_sigreturn_init
446 static struct tramp_frame arm_linux_restart_syscall_tramp_frame
= {
450 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
451 { ARM_LDR_PC_SP_12
, -1 },
452 { TRAMP_SENTINEL_INSN
}
454 arm_linux_restart_syscall_init
457 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame
= {
461 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
462 { ARM_LDR_PC_SP_4
, -1 },
463 { TRAMP_SENTINEL_INSN
}
465 arm_linux_restart_syscall_init
468 /* Core file and register set support. */
470 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
473 arm_linux_supply_gregset (const struct regset
*regset
,
474 struct regcache
*regcache
,
475 int regnum
, const void *gregs_buf
, size_t len
)
477 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
478 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
479 const gdb_byte
*gregs
= gregs_buf
;
482 gdb_byte pc_buf
[INT_REGISTER_SIZE
];
484 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
485 if (regnum
== -1 || regnum
== regno
)
486 regcache_raw_supply (regcache
, regno
,
487 gregs
+ INT_REGISTER_SIZE
* regno
);
489 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
492 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
493 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
495 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
496 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
499 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
501 reg_pc
= extract_unsigned_integer (gregs
502 + INT_REGISTER_SIZE
* ARM_PC_REGNUM
,
503 INT_REGISTER_SIZE
, byte_order
);
504 reg_pc
= gdbarch_addr_bits_remove (gdbarch
, reg_pc
);
505 store_unsigned_integer (pc_buf
, INT_REGISTER_SIZE
, byte_order
, reg_pc
);
506 regcache_raw_supply (regcache
, ARM_PC_REGNUM
, pc_buf
);
511 arm_linux_collect_gregset (const struct regset
*regset
,
512 const struct regcache
*regcache
,
513 int regnum
, void *gregs_buf
, size_t len
)
515 gdb_byte
*gregs
= gregs_buf
;
518 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
519 if (regnum
== -1 || regnum
== regno
)
520 regcache_raw_collect (regcache
, regno
,
521 gregs
+ INT_REGISTER_SIZE
* regno
);
523 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
526 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
527 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
529 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
530 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
533 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
534 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
535 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
538 /* Support for register format used by the NWFPE FPA emulator. */
540 #define typeNone 0x00
541 #define typeSingle 0x01
542 #define typeDouble 0x02
543 #define typeExtended 0x03
546 supply_nwfpe_register (struct regcache
*regcache
, int regno
,
547 const gdb_byte
*regs
)
549 const gdb_byte
*reg_data
;
551 gdb_byte buf
[FP_REGISTER_SIZE
];
553 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
554 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
555 memset (buf
, 0, FP_REGISTER_SIZE
);
560 memcpy (buf
, reg_data
, 4);
563 memcpy (buf
, reg_data
+ 4, 4);
564 memcpy (buf
+ 4, reg_data
, 4);
567 /* We want sign and exponent, then least significant bits,
568 then most significant. NWFPE does sign, most, least. */
569 memcpy (buf
, reg_data
, 4);
570 memcpy (buf
+ 4, reg_data
+ 8, 4);
571 memcpy (buf
+ 8, reg_data
+ 4, 4);
577 regcache_raw_supply (regcache
, regno
, buf
);
581 collect_nwfpe_register (const struct regcache
*regcache
, int regno
,
586 gdb_byte buf
[FP_REGISTER_SIZE
];
588 regcache_raw_collect (regcache
, regno
, buf
);
590 /* NOTE drow/2006-06-07: This code uses the tag already in the
591 register buffer. I've preserved that when moving the code
592 from the native file to the target file. But this doesn't
593 always make sense. */
595 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
596 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
601 memcpy (reg_data
, buf
, 4);
604 memcpy (reg_data
, buf
+ 4, 4);
605 memcpy (reg_data
+ 4, buf
, 4);
608 memcpy (reg_data
, buf
, 4);
609 memcpy (reg_data
+ 4, buf
+ 8, 4);
610 memcpy (reg_data
+ 8, buf
+ 4, 4);
618 arm_linux_supply_nwfpe (const struct regset
*regset
,
619 struct regcache
*regcache
,
620 int regnum
, const void *regs_buf
, size_t len
)
622 const gdb_byte
*regs
= regs_buf
;
625 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
626 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
627 regs
+ NWFPE_FPSR_OFFSET
);
629 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
630 if (regnum
== -1 || regnum
== regno
)
631 supply_nwfpe_register (regcache
, regno
, regs
);
635 arm_linux_collect_nwfpe (const struct regset
*regset
,
636 const struct regcache
*regcache
,
637 int regnum
, void *regs_buf
, size_t len
)
639 gdb_byte
*regs
= regs_buf
;
642 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
643 if (regnum
== -1 || regnum
== regno
)
644 collect_nwfpe_register (regcache
, regno
, regs
);
646 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
647 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
,
648 regs
+ INT_REGISTER_SIZE
* ARM_FPS_REGNUM
);
651 /* Support VFP register format. */
653 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
656 arm_linux_supply_vfp (const struct regset
*regset
,
657 struct regcache
*regcache
,
658 int regnum
, const void *regs_buf
, size_t len
)
660 const gdb_byte
*regs
= regs_buf
;
663 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
664 regcache_raw_supply (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
666 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
667 if (regnum
== -1 || regnum
== regno
)
668 regcache_raw_supply (regcache
, regno
,
669 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
673 arm_linux_collect_vfp (const struct regset
*regset
,
674 const struct regcache
*regcache
,
675 int regnum
, void *regs_buf
, size_t len
)
677 gdb_byte
*regs
= regs_buf
;
680 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
681 regcache_raw_collect (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
683 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
684 if (regnum
== -1 || regnum
== regno
)
685 regcache_raw_collect (regcache
, regno
,
686 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
689 static const struct regset arm_linux_gregset
=
691 NULL
, arm_linux_supply_gregset
, arm_linux_collect_gregset
694 static const struct regset arm_linux_fpregset
=
696 NULL
, arm_linux_supply_nwfpe
, arm_linux_collect_nwfpe
699 static const struct regset arm_linux_vfpregset
=
701 NULL
, arm_linux_supply_vfp
, arm_linux_collect_vfp
704 /* Return the appropriate register set for the core section identified
705 by SECT_NAME and SECT_SIZE. */
707 static const struct regset
*
708 arm_linux_regset_from_core_section (struct gdbarch
*gdbarch
,
709 const char *sect_name
, size_t sect_size
)
711 if (strcmp (sect_name
, ".reg") == 0
712 && sect_size
== ARM_LINUX_SIZEOF_GREGSET
)
713 return &arm_linux_gregset
;
715 if (strcmp (sect_name
, ".reg2") == 0
716 && sect_size
== ARM_LINUX_SIZEOF_NWFPE
)
717 return &arm_linux_fpregset
;
719 if (strcmp (sect_name
, ".reg-arm-vfp") == 0
720 && sect_size
== ARM_LINUX_SIZEOF_VFP
)
721 return &arm_linux_vfpregset
;
726 /* Core file register set sections. */
728 static struct core_regset_section arm_linux_fpa_regset_sections
[] =
730 { ".reg", ARM_LINUX_SIZEOF_GREGSET
, "general-purpose" },
731 { ".reg2", ARM_LINUX_SIZEOF_NWFPE
, "FPA floating-point" },
735 static struct core_regset_section arm_linux_vfp_regset_sections
[] =
737 { ".reg", ARM_LINUX_SIZEOF_GREGSET
, "general-purpose" },
738 { ".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP
, "VFP floating-point" },
742 /* Determine target description from core file. */
744 static const struct target_desc
*
745 arm_linux_core_read_description (struct gdbarch
*gdbarch
,
746 struct target_ops
*target
,
749 CORE_ADDR arm_hwcap
= 0;
751 if (target_auxv_search (target
, AT_HWCAP
, &arm_hwcap
) != 1)
754 if (arm_hwcap
& HWCAP_VFP
)
756 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
757 Neon with VFPv3-D32. */
758 if (arm_hwcap
& HWCAP_NEON
)
759 return tdesc_arm_with_neon
;
760 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
761 return tdesc_arm_with_vfpv3
;
763 return tdesc_arm_with_vfpv2
;
770 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
771 return 1. In addition, set IS_THUMB depending on whether we
772 will return to ARM or Thumb code. Return 0 if it is not a
773 rt_sigreturn/sigreturn syscall. */
775 arm_linux_sigreturn_return_addr (struct frame_info
*frame
,
776 unsigned long svc_number
,
777 CORE_ADDR
*pc
, int *is_thumb
)
779 /* Is this a sigreturn or rt_sigreturn syscall? */
780 if (svc_number
== 119 || svc_number
== 173)
782 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
784 ULONGEST t_bit
= arm_psr_thumb_bit (frame_unwind_arch (frame
));
786 = frame_unwind_register_unsigned (frame
, ARM_PS_REGNUM
);
788 *is_thumb
= (cpsr
& t_bit
) != 0;
789 *pc
= frame_unwind_caller_pc (frame
);
796 /* At a ptrace syscall-stop, return the syscall number. This either
797 comes from the SWI instruction (OABI) or from r7 (EABI).
799 When the function fails, it should return -1. */
802 arm_linux_get_syscall_number (struct gdbarch
*gdbarch
,
805 struct regcache
*regs
= get_thread_regcache (ptid
);
806 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
810 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
812 ULONGEST svc_number
= -1;
814 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &pc
);
815 regcache_cooked_read_unsigned (regs
, ARM_PS_REGNUM
, &cpsr
);
816 is_thumb
= (cpsr
& t_bit
) != 0;
820 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
824 enum bfd_endian byte_order_for_code
=
825 gdbarch_byte_order_for_code (gdbarch
);
827 /* PC gets incremented before the syscall-stop, so read the
828 previous instruction. */
829 unsigned long this_instr
=
830 read_memory_unsigned_integer (pc
- 4, 4, byte_order_for_code
);
832 unsigned long svc_operand
= (0x00ffffff & this_instr
);
837 svc_number
= svc_operand
- 0x900000;
842 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
849 /* When FRAME is at a syscall instruction, return the PC of the next
850 instruction to be executed. */
853 arm_linux_syscall_next_pc (struct frame_info
*frame
)
855 CORE_ADDR pc
= get_frame_pc (frame
);
856 CORE_ADDR return_addr
= 0;
857 int is_thumb
= arm_frame_is_thumb (frame
);
858 ULONGEST svc_number
= 0;
862 svc_number
= get_frame_register_unsigned (frame
, 7);
863 return_addr
= pc
+ 2;
867 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
868 enum bfd_endian byte_order_for_code
=
869 gdbarch_byte_order_for_code (gdbarch
);
870 unsigned long this_instr
=
871 read_memory_unsigned_integer (pc
, 4, byte_order_for_code
);
873 unsigned long svc_operand
= (0x00ffffff & this_instr
);
874 if (svc_operand
) /* OABI. */
876 svc_number
= svc_operand
- 0x900000;
880 svc_number
= get_frame_register_unsigned (frame
, 7);
883 return_addr
= pc
+ 4;
886 arm_linux_sigreturn_return_addr (frame
, svc_number
, &return_addr
, &is_thumb
);
888 /* Addresses for calling Thumb functions have the bit 0 set. */
896 /* Insert a single step breakpoint at the next executed instruction. */
899 arm_linux_software_single_step (struct frame_info
*frame
)
901 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
902 struct address_space
*aspace
= get_frame_address_space (frame
);
905 if (arm_deal_with_atomic_sequence (frame
))
908 next_pc
= arm_get_next_pc (frame
, get_frame_pc (frame
));
910 /* The Linux kernel offers some user-mode helpers in a high page. We can
911 not read this page (as of 2.6.23), and even if we could then we couldn't
912 set breakpoints in it, and even if we could then the atomic operations
913 would fail when interrupted. They are all called as functions and return
914 to the address in LR, so step to there instead. */
915 if (next_pc
> 0xffff0000)
916 next_pc
= get_frame_register_unsigned (frame
, ARM_LR_REGNUM
);
918 arm_insert_single_step_breakpoint (gdbarch
, aspace
, next_pc
);
923 /* Support for displaced stepping of Linux SVC instructions. */
926 arm_linux_cleanup_svc (struct gdbarch
*gdbarch
,
927 struct regcache
*regs
,
928 struct displaced_step_closure
*dsc
)
930 CORE_ADDR from
= dsc
->insn_addr
;
931 ULONGEST apparent_pc
;
934 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &apparent_pc
);
936 within_scratch
= (apparent_pc
>= dsc
->scratch_base
937 && apparent_pc
< (dsc
->scratch_base
938 + DISPLACED_MODIFIED_INSNS
* 4 + 4));
942 fprintf_unfiltered (gdb_stdlog
, "displaced: PC is apparently %.8lx after "
943 "SVC step ", (unsigned long) apparent_pc
);
945 fprintf_unfiltered (gdb_stdlog
, "(within scratch space)\n");
947 fprintf_unfiltered (gdb_stdlog
, "(outside scratch space)\n");
951 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, from
+ 4, BRANCH_WRITE_PC
);
955 arm_linux_copy_svc (struct gdbarch
*gdbarch
, struct regcache
*regs
,
956 struct displaced_step_closure
*dsc
)
958 CORE_ADDR return_to
= 0;
960 struct frame_info
*frame
;
961 unsigned int svc_number
= displaced_read_reg (regs
, dsc
, 7);
962 int is_sigreturn
= 0;
965 frame
= get_current_frame ();
967 is_sigreturn
= arm_linux_sigreturn_return_addr(frame
, svc_number
,
968 &return_to
, &is_thumb
);
971 struct symtab_and_line sal
;
974 fprintf_unfiltered (gdb_stdlog
, "displaced: found "
975 "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
976 (unsigned long) get_frame_pc (frame
));
979 fprintf_unfiltered (gdb_stdlog
, "displaced: unwind pc = %lx. "
980 "Setting momentary breakpoint.\n", (unsigned long) return_to
);
982 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
985 sal
= find_pc_line (return_to
, 0);
987 sal
.section
= find_pc_overlay (return_to
);
990 frame
= get_prev_frame (frame
);
994 inferior_thread ()->control
.step_resume_breakpoint
995 = set_momentary_breakpoint (gdbarch
, sal
, get_frame_id (frame
),
998 /* set_momentary_breakpoint invalidates FRAME. */
1001 /* We need to make sure we actually insert the momentary
1002 breakpoint set above. */
1003 insert_breakpoints ();
1005 else if (debug_displaced
)
1006 fprintf_unfiltered (gdb_stderr
, "displaced: couldn't find previous "
1007 "frame to set momentary breakpoint for "
1008 "sigreturn/rt_sigreturn\n");
1010 else if (debug_displaced
)
1011 fprintf_unfiltered (gdb_stdlog
, "displaced: sigreturn/rt_sigreturn "
1012 "SVC call not in signal trampoline frame\n");
1015 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1016 location, else nothing.
1017 Insn: unmodified svc.
1018 Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
1019 else leave pc alone. */
1022 dsc
->cleanup
= &arm_linux_cleanup_svc
;
1023 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1025 dsc
->wrote_to_pc
= 1;
1031 /* The following two functions implement single-stepping over calls to Linux
1032 kernel helper routines, which perform e.g. atomic operations on architecture
1033 variants which don't support them natively.
1035 When this function is called, the PC will be pointing at the kernel helper
1036 (at an address inaccessible to GDB), and r14 will point to the return
1037 address. Displaced stepping always executes code in the copy area:
1038 so, make the copy-area instruction branch back to the kernel helper (the
1039 "from" address), and make r14 point to the breakpoint in the copy area. In
1040 that way, we regain control once the kernel helper returns, and can clean
1041 up appropriately (as if we had just returned from the kernel helper as it
1042 would have been called from the non-displaced location). */
1045 cleanup_kernel_helper_return (struct gdbarch
*gdbarch
,
1046 struct regcache
*regs
,
1047 struct displaced_step_closure
*dsc
)
1049 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, dsc
->tmp
[0], CANNOT_WRITE_PC
);
1050 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, dsc
->tmp
[0], BRANCH_WRITE_PC
);
1054 arm_catch_kernel_helper_return (struct gdbarch
*gdbarch
, CORE_ADDR from
,
1055 CORE_ADDR to
, struct regcache
*regs
,
1056 struct displaced_step_closure
*dsc
)
1058 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1061 dsc
->insn_addr
= from
;
1062 dsc
->cleanup
= &cleanup_kernel_helper_return
;
1063 /* Say we wrote to the PC, else cleanup will set PC to the next
1064 instruction in the helper, which isn't helpful. */
1065 dsc
->wrote_to_pc
= 1;
1067 /* Preparation: tmp[0] <- r14
1068 r14 <- <scratch space>+4
1069 *(<scratch space>+8) <- from
1070 Insn: ldr pc, [r14, #4]
1071 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
1073 dsc
->tmp
[0] = displaced_read_reg (regs
, dsc
, ARM_LR_REGNUM
);
1074 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, (ULONGEST
) to
+ 4,
1076 write_memory_unsigned_integer (to
+ 8, 4, byte_order
, from
);
1078 dsc
->modinsn
[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
1081 /* Linux-specific displaced step instruction copying function. Detects when
1082 the program has stepped into a Linux kernel helper routine (which must be
1083 handled as a special case), falling back to arm_displaced_step_copy_insn()
1086 static struct displaced_step_closure
*
1087 arm_linux_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
1088 CORE_ADDR from
, CORE_ADDR to
,
1089 struct regcache
*regs
)
1091 struct displaced_step_closure
*dsc
1092 = xmalloc (sizeof (struct displaced_step_closure
));
1094 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1095 stop at the return location. */
1096 if (from
> 0xffff0000)
1098 if (debug_displaced
)
1099 fprintf_unfiltered (gdb_stdlog
, "displaced: detected kernel helper "
1100 "at %.8lx\n", (unsigned long) from
);
1102 arm_catch_kernel_helper_return (gdbarch
, from
, to
, regs
, dsc
);
1106 /* Override the default handling of SVC instructions. */
1107 dsc
->u
.svc
.copy_svc_os
= arm_linux_copy_svc
;
1109 arm_process_displaced_insn (gdbarch
, from
, to
, regs
, dsc
);
1112 arm_displaced_init_closure (gdbarch
, from
, to
, dsc
);
1117 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1121 arm_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1123 return (*s
== '#' || *s
== '$' || isdigit (*s
) /* Literal number. */
1124 || *s
== '[' /* Register indirection or
1126 || isalpha (*s
)); /* Register value. */
1129 /* This routine is used to parse a special token in ARM's assembly.
1131 The special tokens parsed by it are:
1133 - Register displacement (e.g, [fp, #-8])
1135 It returns one if the special token has been parsed successfully,
1136 or zero if the current token is not considered special. */
1139 arm_stap_parse_special_token (struct gdbarch
*gdbarch
,
1140 struct stap_parse_info
*p
)
1144 /* Temporary holder for lookahead. */
1145 const char *tmp
= p
->arg
;
1147 /* Used to save the register name. */
1158 /* Register name. */
1159 while (isalnum (*tmp
))
1166 regname
= alloca (len
+ 2);
1169 if (isdigit (*start
))
1171 /* If we are dealing with a register whose name begins with a
1172 digit, it means we should prefix the name with the letter
1173 `r', because GDB expects this name pattern. Otherwise (e.g.,
1174 we are dealing with the register `fp'), we don't need to
1175 add such a prefix. */
1180 strncpy (regname
+ offset
, start
, len
);
1182 regname
[len
] = '\0';
1184 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1185 error (_("Invalid register name `%s' on expression `%s'."),
1186 regname
, p
->saved_arg
);
1189 tmp
= skip_spaces_const (tmp
);
1190 if (*tmp
== '#' || *tmp
== '$')
1199 displacement
= strtol (tmp
, &endp
, 10);
1202 /* Skipping last `]'. */
1206 /* The displacement. */
1207 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1208 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
1209 write_exp_elt_longcst (&p
->pstate
, displacement
);
1210 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1212 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
1214 /* The register name. */
1215 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1218 write_exp_string (&p
->pstate
, str
);
1219 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1221 write_exp_elt_opcode (&p
->pstate
, BINOP_ADD
);
1223 /* Casting to the expected type. */
1224 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1225 write_exp_elt_type (&p
->pstate
, lookup_pointer_type (p
->arg_type
));
1226 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1228 write_exp_elt_opcode (&p
->pstate
, UNOP_IND
);
1238 /* ARM process record-replay constructs: syscall, signal etc. */
1240 struct linux_record_tdep arm_linux_record_tdep
;
1242 /* arm_canonicalize_syscall maps from the native arm Linux set
1243 of syscall ids into a canonical set of syscall ids used by
1246 static enum gdb_syscall
1247 arm_canonicalize_syscall (int syscall
)
1249 enum { sys_process_vm_writev
= 377 };
1251 if (syscall
<= gdb_sys_sched_getaffinity
)
1253 else if (syscall
>= 243 && syscall
<= 247)
1255 else if (syscall
>= 248 && syscall
<= 253)
1261 /* Record all registers but PC register for process-record. */
1264 arm_all_but_pc_registers_record (struct regcache
*regcache
)
1268 for (i
= 0; i
< ARM_PC_REGNUM
; i
++)
1270 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
+ i
))
1274 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1280 /* Handler for arm system call instruction recording. */
1283 arm_linux_syscall_record (struct regcache
*regcache
, unsigned long svc_number
)
1286 enum gdb_syscall syscall_gdb
;
1288 syscall_gdb
= arm_canonicalize_syscall (svc_number
);
1290 if (syscall_gdb
< 0)
1292 printf_unfiltered (_("Process record and replay target doesn't "
1293 "support syscall number %s\n"),
1294 plongest (svc_number
));
1298 if (syscall_gdb
== gdb_sys_sigreturn
1299 || syscall_gdb
== gdb_sys_rt_sigreturn
)
1301 if (arm_all_but_pc_registers_record (regcache
))
1306 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1307 &arm_linux_record_tdep
);
1311 /* Record the return value of the system call. */
1312 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
))
1315 if (record_full_arch_list_add_reg (regcache
, ARM_LR_REGNUM
))
1318 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1325 arm_linux_init_abi (struct gdbarch_info info
,
1326 struct gdbarch
*gdbarch
)
1328 static const char *const stap_integer_prefixes
[] = { "#", "$", "", NULL
};
1329 static const char *const stap_register_prefixes
[] = { "r", NULL
};
1330 static const char *const stap_register_indirection_prefixes
[] = { "[",
1332 static const char *const stap_register_indirection_suffixes
[] = { "]",
1334 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1336 linux_init_abi (info
, gdbarch
);
1338 tdep
->lowest_pc
= 0x8000;
1339 if (info
.byte_order
== BFD_ENDIAN_BIG
)
1341 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1342 tdep
->arm_breakpoint
= eabi_linux_arm_be_breakpoint
;
1344 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
1345 tdep
->thumb_breakpoint
= arm_linux_thumb_be_breakpoint
;
1346 tdep
->thumb2_breakpoint
= arm_linux_thumb2_be_breakpoint
;
1350 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1351 tdep
->arm_breakpoint
= eabi_linux_arm_le_breakpoint
;
1353 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
1354 tdep
->thumb_breakpoint
= arm_linux_thumb_le_breakpoint
;
1355 tdep
->thumb2_breakpoint
= arm_linux_thumb2_le_breakpoint
;
1357 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
1358 tdep
->thumb_breakpoint_size
= sizeof (arm_linux_thumb_le_breakpoint
);
1359 tdep
->thumb2_breakpoint_size
= sizeof (arm_linux_thumb2_le_breakpoint
);
1361 if (tdep
->fp_model
== ARM_FLOAT_AUTO
)
1362 tdep
->fp_model
= ARM_FLOAT_FPA
;
1364 switch (tdep
->fp_model
)
1367 tdep
->jb_pc
= ARM_LINUX_JB_PC_FPA
;
1369 case ARM_FLOAT_SOFT_FPA
:
1370 case ARM_FLOAT_SOFT_VFP
:
1372 tdep
->jb_pc
= ARM_LINUX_JB_PC_EABI
;
1376 (__FILE__
, __LINE__
,
1377 _("arm_linux_init_abi: Floating point model not supported"));
1380 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
1382 set_solib_svr4_fetch_link_map_offsets
1383 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1385 /* Single stepping. */
1386 set_gdbarch_software_single_step (gdbarch
, arm_linux_software_single_step
);
1388 /* Shared library handling. */
1389 set_gdbarch_skip_trampoline_code (gdbarch
, find_solib_trampoline_target
);
1390 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
1392 /* Enable TLS support. */
1393 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1394 svr4_fetch_objfile_link_map
);
1396 tramp_frame_prepend_unwinder (gdbarch
,
1397 &arm_linux_sigreturn_tramp_frame
);
1398 tramp_frame_prepend_unwinder (gdbarch
,
1399 &arm_linux_rt_sigreturn_tramp_frame
);
1400 tramp_frame_prepend_unwinder (gdbarch
,
1401 &arm_eabi_linux_sigreturn_tramp_frame
);
1402 tramp_frame_prepend_unwinder (gdbarch
,
1403 &arm_eabi_linux_rt_sigreturn_tramp_frame
);
1404 tramp_frame_prepend_unwinder (gdbarch
,
1405 &arm_linux_restart_syscall_tramp_frame
);
1406 tramp_frame_prepend_unwinder (gdbarch
,
1407 &arm_kernel_linux_restart_syscall_tramp_frame
);
1409 /* Core file support. */
1410 set_gdbarch_regset_from_core_section (gdbarch
,
1411 arm_linux_regset_from_core_section
);
1412 set_gdbarch_core_read_description (gdbarch
, arm_linux_core_read_description
);
1414 if (tdep
->have_vfp_registers
)
1415 set_gdbarch_core_regset_sections (gdbarch
, arm_linux_vfp_regset_sections
);
1416 else if (tdep
->have_fpa_registers
)
1417 set_gdbarch_core_regset_sections (gdbarch
, arm_linux_fpa_regset_sections
);
1419 set_gdbarch_get_siginfo_type (gdbarch
, linux_get_siginfo_type
);
1421 /* Displaced stepping. */
1422 set_gdbarch_displaced_step_copy_insn (gdbarch
,
1423 arm_linux_displaced_step_copy_insn
);
1424 set_gdbarch_displaced_step_fixup (gdbarch
, arm_displaced_step_fixup
);
1425 set_gdbarch_displaced_step_free_closure (gdbarch
,
1426 simple_displaced_step_free_closure
);
1427 set_gdbarch_displaced_step_location (gdbarch
, displaced_step_at_entry_point
);
1429 /* Reversible debugging, process record. */
1430 set_gdbarch_process_record (gdbarch
, arm_process_record
);
1432 /* SystemTap functions. */
1433 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
1434 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
1435 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
1436 stap_register_indirection_prefixes
);
1437 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
1438 stap_register_indirection_suffixes
);
1439 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
1440 set_gdbarch_stap_is_single_operand (gdbarch
, arm_stap_is_single_operand
);
1441 set_gdbarch_stap_parse_special_token (gdbarch
,
1442 arm_stap_parse_special_token
);
1444 tdep
->syscall_next_pc
= arm_linux_syscall_next_pc
;
1446 /* `catch syscall' */
1447 set_xml_syscall_file_name ("syscalls/arm-linux.xml");
1448 set_gdbarch_get_syscall_number (gdbarch
, arm_linux_get_syscall_number
);
1450 /* Syscall record. */
1451 tdep
->arm_syscall_record
= arm_linux_syscall_record
;
1453 /* Initialize the arm_linux_record_tdep. */
1454 /* These values are the size of the type that will be used in a system
1455 call. They are obtained from Linux Kernel source. */
1456 arm_linux_record_tdep
.size_pointer
1457 = gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1458 arm_linux_record_tdep
.size__old_kernel_stat
= 32;
1459 arm_linux_record_tdep
.size_tms
= 16;
1460 arm_linux_record_tdep
.size_loff_t
= 8;
1461 arm_linux_record_tdep
.size_flock
= 16;
1462 arm_linux_record_tdep
.size_oldold_utsname
= 45;
1463 arm_linux_record_tdep
.size_ustat
= 20;
1464 arm_linux_record_tdep
.size_old_sigaction
= 140;
1465 arm_linux_record_tdep
.size_old_sigset_t
= 128;
1466 arm_linux_record_tdep
.size_rlimit
= 8;
1467 arm_linux_record_tdep
.size_rusage
= 72;
1468 arm_linux_record_tdep
.size_timeval
= 8;
1469 arm_linux_record_tdep
.size_timezone
= 8;
1470 arm_linux_record_tdep
.size_old_gid_t
= 2;
1471 arm_linux_record_tdep
.size_old_uid_t
= 2;
1472 arm_linux_record_tdep
.size_fd_set
= 128;
1473 arm_linux_record_tdep
.size_dirent
= 268;
1474 arm_linux_record_tdep
.size_dirent64
= 276;
1475 arm_linux_record_tdep
.size_statfs
= 64;
1476 arm_linux_record_tdep
.size_statfs64
= 84;
1477 arm_linux_record_tdep
.size_sockaddr
= 16;
1478 arm_linux_record_tdep
.size_int
1479 = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
1480 arm_linux_record_tdep
.size_long
1481 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1482 arm_linux_record_tdep
.size_ulong
1483 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1484 arm_linux_record_tdep
.size_msghdr
= 28;
1485 arm_linux_record_tdep
.size_itimerval
= 16;
1486 arm_linux_record_tdep
.size_stat
= 88;
1487 arm_linux_record_tdep
.size_old_utsname
= 325;
1488 arm_linux_record_tdep
.size_sysinfo
= 64;
1489 arm_linux_record_tdep
.size_msqid_ds
= 88;
1490 arm_linux_record_tdep
.size_shmid_ds
= 84;
1491 arm_linux_record_tdep
.size_new_utsname
= 390;
1492 arm_linux_record_tdep
.size_timex
= 128;
1493 arm_linux_record_tdep
.size_mem_dqinfo
= 24;
1494 arm_linux_record_tdep
.size_if_dqblk
= 68;
1495 arm_linux_record_tdep
.size_fs_quota_stat
= 68;
1496 arm_linux_record_tdep
.size_timespec
= 8;
1497 arm_linux_record_tdep
.size_pollfd
= 8;
1498 arm_linux_record_tdep
.size_NFS_FHSIZE
= 32;
1499 arm_linux_record_tdep
.size_knfsd_fh
= 132;
1500 arm_linux_record_tdep
.size_TASK_COMM_LEN
= 16;
1501 arm_linux_record_tdep
.size_sigaction
= 140;
1502 arm_linux_record_tdep
.size_sigset_t
= 8;
1503 arm_linux_record_tdep
.size_siginfo_t
= 128;
1504 arm_linux_record_tdep
.size_cap_user_data_t
= 12;
1505 arm_linux_record_tdep
.size_stack_t
= 12;
1506 arm_linux_record_tdep
.size_off_t
= arm_linux_record_tdep
.size_long
;
1507 arm_linux_record_tdep
.size_stat64
= 96;
1508 arm_linux_record_tdep
.size_gid_t
= 2;
1509 arm_linux_record_tdep
.size_uid_t
= 2;
1510 arm_linux_record_tdep
.size_PAGE_SIZE
= 4096;
1511 arm_linux_record_tdep
.size_flock64
= 24;
1512 arm_linux_record_tdep
.size_user_desc
= 16;
1513 arm_linux_record_tdep
.size_io_event
= 32;
1514 arm_linux_record_tdep
.size_iocb
= 64;
1515 arm_linux_record_tdep
.size_epoll_event
= 12;
1516 arm_linux_record_tdep
.size_itimerspec
1517 = arm_linux_record_tdep
.size_timespec
* 2;
1518 arm_linux_record_tdep
.size_mq_attr
= 32;
1519 arm_linux_record_tdep
.size_siginfo
= 128;
1520 arm_linux_record_tdep
.size_termios
= 36;
1521 arm_linux_record_tdep
.size_termios2
= 44;
1522 arm_linux_record_tdep
.size_pid_t
= 4;
1523 arm_linux_record_tdep
.size_winsize
= 8;
1524 arm_linux_record_tdep
.size_serial_struct
= 60;
1525 arm_linux_record_tdep
.size_serial_icounter_struct
= 80;
1526 arm_linux_record_tdep
.size_hayes_esp_config
= 12;
1527 arm_linux_record_tdep
.size_size_t
= 4;
1528 arm_linux_record_tdep
.size_iovec
= 8;
1530 /* These values are the second argument of system call "sys_ioctl".
1531 They are obtained from Linux Kernel source. */
1532 arm_linux_record_tdep
.ioctl_TCGETS
= 0x5401;
1533 arm_linux_record_tdep
.ioctl_TCSETS
= 0x5402;
1534 arm_linux_record_tdep
.ioctl_TCSETSW
= 0x5403;
1535 arm_linux_record_tdep
.ioctl_TCSETSF
= 0x5404;
1536 arm_linux_record_tdep
.ioctl_TCGETA
= 0x5405;
1537 arm_linux_record_tdep
.ioctl_TCSETA
= 0x5406;
1538 arm_linux_record_tdep
.ioctl_TCSETAW
= 0x5407;
1539 arm_linux_record_tdep
.ioctl_TCSETAF
= 0x5408;
1540 arm_linux_record_tdep
.ioctl_TCSBRK
= 0x5409;
1541 arm_linux_record_tdep
.ioctl_TCXONC
= 0x540a;
1542 arm_linux_record_tdep
.ioctl_TCFLSH
= 0x540b;
1543 arm_linux_record_tdep
.ioctl_TIOCEXCL
= 0x540c;
1544 arm_linux_record_tdep
.ioctl_TIOCNXCL
= 0x540d;
1545 arm_linux_record_tdep
.ioctl_TIOCSCTTY
= 0x540e;
1546 arm_linux_record_tdep
.ioctl_TIOCGPGRP
= 0x540f;
1547 arm_linux_record_tdep
.ioctl_TIOCSPGRP
= 0x5410;
1548 arm_linux_record_tdep
.ioctl_TIOCOUTQ
= 0x5411;
1549 arm_linux_record_tdep
.ioctl_TIOCSTI
= 0x5412;
1550 arm_linux_record_tdep
.ioctl_TIOCGWINSZ
= 0x5413;
1551 arm_linux_record_tdep
.ioctl_TIOCSWINSZ
= 0x5414;
1552 arm_linux_record_tdep
.ioctl_TIOCMGET
= 0x5415;
1553 arm_linux_record_tdep
.ioctl_TIOCMBIS
= 0x5416;
1554 arm_linux_record_tdep
.ioctl_TIOCMBIC
= 0x5417;
1555 arm_linux_record_tdep
.ioctl_TIOCMSET
= 0x5418;
1556 arm_linux_record_tdep
.ioctl_TIOCGSOFTCAR
= 0x5419;
1557 arm_linux_record_tdep
.ioctl_TIOCSSOFTCAR
= 0x541a;
1558 arm_linux_record_tdep
.ioctl_FIONREAD
= 0x541b;
1559 arm_linux_record_tdep
.ioctl_TIOCINQ
= arm_linux_record_tdep
.ioctl_FIONREAD
;
1560 arm_linux_record_tdep
.ioctl_TIOCLINUX
= 0x541c;
1561 arm_linux_record_tdep
.ioctl_TIOCCONS
= 0x541d;
1562 arm_linux_record_tdep
.ioctl_TIOCGSERIAL
= 0x541e;
1563 arm_linux_record_tdep
.ioctl_TIOCSSERIAL
= 0x541f;
1564 arm_linux_record_tdep
.ioctl_TIOCPKT
= 0x5420;
1565 arm_linux_record_tdep
.ioctl_FIONBIO
= 0x5421;
1566 arm_linux_record_tdep
.ioctl_TIOCNOTTY
= 0x5422;
1567 arm_linux_record_tdep
.ioctl_TIOCSETD
= 0x5423;
1568 arm_linux_record_tdep
.ioctl_TIOCGETD
= 0x5424;
1569 arm_linux_record_tdep
.ioctl_TCSBRKP
= 0x5425;
1570 arm_linux_record_tdep
.ioctl_TIOCTTYGSTRUCT
= 0x5426;
1571 arm_linux_record_tdep
.ioctl_TIOCSBRK
= 0x5427;
1572 arm_linux_record_tdep
.ioctl_TIOCCBRK
= 0x5428;
1573 arm_linux_record_tdep
.ioctl_TIOCGSID
= 0x5429;
1574 arm_linux_record_tdep
.ioctl_TCGETS2
= 0x802c542a;
1575 arm_linux_record_tdep
.ioctl_TCSETS2
= 0x402c542b;
1576 arm_linux_record_tdep
.ioctl_TCSETSW2
= 0x402c542c;
1577 arm_linux_record_tdep
.ioctl_TCSETSF2
= 0x402c542d;
1578 arm_linux_record_tdep
.ioctl_TIOCGPTN
= 0x80045430;
1579 arm_linux_record_tdep
.ioctl_TIOCSPTLCK
= 0x40045431;
1580 arm_linux_record_tdep
.ioctl_FIONCLEX
= 0x5450;
1581 arm_linux_record_tdep
.ioctl_FIOCLEX
= 0x5451;
1582 arm_linux_record_tdep
.ioctl_FIOASYNC
= 0x5452;
1583 arm_linux_record_tdep
.ioctl_TIOCSERCONFIG
= 0x5453;
1584 arm_linux_record_tdep
.ioctl_TIOCSERGWILD
= 0x5454;
1585 arm_linux_record_tdep
.ioctl_TIOCSERSWILD
= 0x5455;
1586 arm_linux_record_tdep
.ioctl_TIOCGLCKTRMIOS
= 0x5456;
1587 arm_linux_record_tdep
.ioctl_TIOCSLCKTRMIOS
= 0x5457;
1588 arm_linux_record_tdep
.ioctl_TIOCSERGSTRUCT
= 0x5458;
1589 arm_linux_record_tdep
.ioctl_TIOCSERGETLSR
= 0x5459;
1590 arm_linux_record_tdep
.ioctl_TIOCSERGETMULTI
= 0x545a;
1591 arm_linux_record_tdep
.ioctl_TIOCSERSETMULTI
= 0x545b;
1592 arm_linux_record_tdep
.ioctl_TIOCMIWAIT
= 0x545c;
1593 arm_linux_record_tdep
.ioctl_TIOCGICOUNT
= 0x545d;
1594 arm_linux_record_tdep
.ioctl_TIOCGHAYESESP
= 0x545e;
1595 arm_linux_record_tdep
.ioctl_TIOCSHAYESESP
= 0x545f;
1596 arm_linux_record_tdep
.ioctl_FIOQSIZE
= 0x5460;
1598 /* These values are the second argument of system call "sys_fcntl"
1599 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1600 arm_linux_record_tdep
.fcntl_F_GETLK
= 5;
1601 arm_linux_record_tdep
.fcntl_F_GETLK64
= 12;
1602 arm_linux_record_tdep
.fcntl_F_SETLK64
= 13;
1603 arm_linux_record_tdep
.fcntl_F_SETLKW64
= 14;
1605 arm_linux_record_tdep
.arg1
= ARM_A1_REGNUM
+ 1;
1606 arm_linux_record_tdep
.arg2
= ARM_A1_REGNUM
+ 2;
1607 arm_linux_record_tdep
.arg3
= ARM_A1_REGNUM
+ 3;
1608 arm_linux_record_tdep
.arg4
= ARM_A1_REGNUM
+ 3;
1611 /* Provide a prototype to silence -Wmissing-prototypes. */
1612 extern initialize_file_ftype _initialize_arm_linux_tdep
;
1615 _initialize_arm_linux_tdep (void)
1617 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,
1618 arm_linux_init_abi
);