1 /* GNU/Linux on ARM target support.
3 Copyright (C) 1999-2016 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 "arch/arm-get-next-pcs.h"
40 #include "arch/arm-linux.h"
42 #include "arm-linux-tdep.h"
43 #include "linux-tdep.h"
44 #include "glibc-tdep.h"
45 #include "arch-utils.h"
48 #include "gdbthread.h"
51 #include "record-full.h"
52 #include "linux-record.h"
54 #include "cli/cli-utils.h"
55 #include "stap-probe.h"
56 #include "parser-defs.h"
57 #include "user-regs.h"
59 #include "elf/common.h"
60 extern int arm_apcs_32
;
62 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
63 is to execute a particular software interrupt, rather than use a
64 particular undefined instruction to provoke a trap. Upon exection
65 of the software interrupt the kernel stops the inferior with a
66 SIGTRAP, and wakes the debugger. */
68 static const gdb_byte arm_linux_arm_le_breakpoint
[] = { 0x01, 0x00, 0x9f, 0xef };
70 static const gdb_byte arm_linux_arm_be_breakpoint
[] = { 0xef, 0x9f, 0x00, 0x01 };
72 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
73 the operand of the swi if old-ABI compatibility is disabled. Therefore,
74 use an undefined instruction instead. This is supported as of kernel
75 version 2.5.70 (May 2003), so should be a safe assumption for EABI
78 static const gdb_byte eabi_linux_arm_le_breakpoint
[] = { 0xf0, 0x01, 0xf0, 0xe7 };
80 static const gdb_byte eabi_linux_arm_be_breakpoint
[] = { 0xe7, 0xf0, 0x01, 0xf0 };
82 /* All the kernels which support Thumb support using a specific undefined
83 instruction for the Thumb breakpoint. */
85 static const gdb_byte arm_linux_thumb_be_breakpoint
[] = {0xde, 0x01};
87 static const gdb_byte arm_linux_thumb_le_breakpoint
[] = {0x01, 0xde};
89 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
90 we must use a length-appropriate breakpoint for 32-bit Thumb
91 instructions. See also thumb_get_next_pc. */
93 static const gdb_byte arm_linux_thumb2_be_breakpoint
[] = { 0xf7, 0xf0, 0xa0, 0x00 };
95 static const gdb_byte arm_linux_thumb2_le_breakpoint
[] = { 0xf0, 0xf7, 0x00, 0xa0 };
97 /* Description of the longjmp buffer. The buffer is treated as an array of
98 elements of size ARM_LINUX_JB_ELEMENT_SIZE.
100 The location of saved registers in this buffer (in particular the PC
101 to use after longjmp is called) varies depending on the ABI (in
102 particular the FP model) and also (possibly) the C Library.
104 For glibc, eglibc, and uclibc the following holds: If the FP model is
105 SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
106 buffer. This is also true for the SoftFPA model. However, for the FPA
107 model the PC is at offset 21 in the buffer. */
108 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
109 #define ARM_LINUX_JB_PC_FPA 21
110 #define ARM_LINUX_JB_PC_EABI 9
113 Dynamic Linking on ARM GNU/Linux
114 --------------------------------
116 Note: PLT = procedure linkage table
117 GOT = global offset table
119 As much as possible, ELF dynamic linking defers the resolution of
120 jump/call addresses until the last minute. The technique used is
121 inspired by the i386 ELF design, and is based on the following
124 1) The calling technique should not force a change in the assembly
125 code produced for apps; it MAY cause changes in the way assembly
126 code is produced for position independent code (i.e. shared
129 2) The technique must be such that all executable areas must not be
130 modified; and any modified areas must not be executed.
132 To do this, there are three steps involved in a typical jump:
136 3) using a pointer from the GOT
138 When the executable or library is first loaded, each GOT entry is
139 initialized to point to the code which implements dynamic name
140 resolution and code finding. This is normally a function in the
141 program interpreter (on ARM GNU/Linux this is usually
142 ld-linux.so.2, but it does not have to be). On the first
143 invocation, the function is located and the GOT entry is replaced
144 with the real function address. Subsequent calls go through steps
145 1, 2 and 3 and end up calling the real code.
152 This is typical ARM code using the 26 bit relative branch or branch
153 and link instructions. The target of the instruction
154 (function_call is usually the address of the function to be called.
155 In position independent code, the target of the instruction is
156 actually an entry in the PLT when calling functions in a shared
157 library. Note that this call is identical to a normal function
158 call, only the target differs.
162 The PLT is a synthetic area, created by the linker. It exists in
163 both executables and libraries. It is an array of stubs, one per
164 imported function call. It looks like this:
167 str lr, [sp, #-4]! @push the return address (lr)
168 ldr lr, [pc, #16] @load from 6 words ahead
169 add lr, pc, lr @form an address for GOT[0]
170 ldr pc, [lr, #8]! @jump to the contents of that addr
172 The return address (lr) is pushed on the stack and used for
173 calculations. The load on the second line loads the lr with
174 &GOT[3] - . - 20. The addition on the third leaves:
176 lr = (&GOT[3] - . - 20) + (. + 8)
180 On the fourth line, the pc and lr are both updated, so that:
186 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
187 "tight", but allows us to keep all the PLT entries the same size.
190 ldr ip, [pc, #4] @load offset from gotoff
191 add ip, pc, ip @add the offset to the pc
192 ldr pc, [ip] @jump to that address
193 gotoff: .word GOT[n+3] - .
195 The load on the first line, gets an offset from the fourth word of
196 the PLT entry. The add on the second line makes ip = &GOT[n+3],
197 which contains either a pointer to PLT[0] (the fixup trampoline) or
198 a pointer to the actual code.
202 The GOT contains helper pointers for both code (PLT) fixups and
203 data fixups. The first 3 entries of the GOT are special. The next
204 M entries (where M is the number of entries in the PLT) belong to
205 the PLT fixups. The next D (all remaining) entries belong to
206 various data fixups. The actual size of the GOT is 3 + M + D.
208 The GOT is also a synthetic area, created by the linker. It exists
209 in both executables and libraries. When the GOT is first
210 initialized , all the GOT entries relating to PLT fixups are
211 pointing to code back at PLT[0].
213 The special entries in the GOT are:
215 GOT[0] = linked list pointer used by the dynamic loader
216 GOT[1] = pointer to the reloc table for this module
217 GOT[2] = pointer to the fixup/resolver code
219 The first invocation of function call comes through and uses the
220 fixup/resolver code. On the entry to the fixup/resolver code:
224 stack[0] = return address (lr) of the function call
225 [r0, r1, r2, r3] are still the arguments to the function call
227 This is enough information for the fixup/resolver code to work
228 with. Before the fixup/resolver code returns, it actually calls
229 the requested function and repairs &GOT[n+3]. */
231 /* The constants below were determined by examining the following files
232 in the linux kernel sources:
234 arch/arm/kernel/signal.c
235 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
236 include/asm-arm/unistd.h
237 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
239 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
240 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
242 /* For ARM EABI, the syscall number is not in the SWI instruction
243 (instead it is loaded into r7). We recognize the pattern that
244 glibc uses... alternatively, we could arrange to do this by
245 function name, but they are not always exported. */
246 #define ARM_SET_R7_SIGRETURN 0xe3a07077
247 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
248 #define ARM_EABI_SYSCALL 0xef000000
250 /* Equivalent patterns for Thumb2. */
251 #define THUMB2_SET_R7_SIGRETURN1 0xf04f
252 #define THUMB2_SET_R7_SIGRETURN2 0x0777
253 #define THUMB2_SET_R7_RT_SIGRETURN1 0xf04f
254 #define THUMB2_SET_R7_RT_SIGRETURN2 0x07ad
255 #define THUMB2_EABI_SYSCALL 0xdf00
257 /* OABI syscall restart trampoline, used for EABI executables too
258 whenever OABI support has been enabled in the kernel. */
259 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
260 #define ARM_LDR_PC_SP_12 0xe49df00c
261 #define ARM_LDR_PC_SP_4 0xe49df004
263 /* Syscall number for sigreturn. */
264 #define ARM_SIGRETURN 119
265 /* Syscall number for rt_sigreturn. */
266 #define ARM_RT_SIGRETURN 173
269 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
,
272 /* Operation function pointers for get_next_pcs. */
273 static struct arm_get_next_pcs_ops arm_linux_get_next_pcs_ops
= {
274 arm_get_next_pcs_read_memory_unsigned_integer
,
275 arm_linux_get_next_pcs_syscall_next_pc
,
276 arm_get_next_pcs_addr_bits_remove
,
277 arm_get_next_pcs_is_thumb
281 arm_linux_sigtramp_cache (struct frame_info
*this_frame
,
282 struct trad_frame_cache
*this_cache
,
283 CORE_ADDR func
, int regs_offset
)
285 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
286 CORE_ADDR base
= sp
+ regs_offset
;
289 for (i
= 0; i
< 16; i
++)
290 trad_frame_set_reg_addr (this_cache
, i
, base
+ i
* 4);
292 trad_frame_set_reg_addr (this_cache
, ARM_PS_REGNUM
, base
+ 16 * 4);
294 /* The VFP or iWMMXt registers may be saved on the stack, but there's
295 no reliable way to restore them (yet). */
297 /* Save a frame ID. */
298 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
301 /* See arm-linux.h for stack layout details. */
303 arm_linux_sigreturn_init (const struct tramp_frame
*self
,
304 struct frame_info
*this_frame
,
305 struct trad_frame_cache
*this_cache
,
308 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
309 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
310 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
311 ULONGEST uc_flags
= read_memory_unsigned_integer (sp
, 4, byte_order
);
313 if (uc_flags
== ARM_NEW_SIGFRAME_MAGIC
)
314 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
315 ARM_UCONTEXT_SIGCONTEXT
316 + ARM_SIGCONTEXT_R0
);
318 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
323 arm_linux_rt_sigreturn_init (const struct tramp_frame
*self
,
324 struct frame_info
*this_frame
,
325 struct trad_frame_cache
*this_cache
,
328 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
329 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
330 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
331 ULONGEST pinfo
= read_memory_unsigned_integer (sp
, 4, byte_order
);
333 if (pinfo
== sp
+ ARM_OLD_RT_SIGFRAME_SIGINFO
)
334 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
335 ARM_OLD_RT_SIGFRAME_UCONTEXT
336 + ARM_UCONTEXT_SIGCONTEXT
337 + ARM_SIGCONTEXT_R0
);
339 arm_linux_sigtramp_cache (this_frame
, this_cache
, func
,
340 ARM_NEW_RT_SIGFRAME_UCONTEXT
341 + ARM_UCONTEXT_SIGCONTEXT
342 + ARM_SIGCONTEXT_R0
);
346 arm_linux_restart_syscall_init (const struct tramp_frame
*self
,
347 struct frame_info
*this_frame
,
348 struct trad_frame_cache
*this_cache
,
351 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
352 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, ARM_SP_REGNUM
);
353 CORE_ADDR pc
= get_frame_memory_unsigned (this_frame
, sp
, 4);
354 CORE_ADDR cpsr
= get_frame_register_unsigned (this_frame
, ARM_PS_REGNUM
);
355 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
358 /* There are two variants of this trampoline; with older kernels, the
359 stub is placed on the stack, while newer kernels use the stub from
360 the vector page. They are identical except that the older version
361 increments SP by 12 (to skip stored PC and the stub itself), while
362 the newer version increments SP only by 4 (just the stored PC). */
363 if (self
->insn
[1].bytes
== ARM_LDR_PC_SP_4
)
368 /* Update Thumb bit in CPSR. */
374 /* Remove Thumb bit from PC. */
375 pc
= gdbarch_addr_bits_remove (gdbarch
, pc
);
377 /* Save previous register values. */
378 trad_frame_set_reg_value (this_cache
, ARM_SP_REGNUM
, sp
+ sp_offset
);
379 trad_frame_set_reg_value (this_cache
, ARM_PC_REGNUM
, pc
);
380 trad_frame_set_reg_value (this_cache
, ARM_PS_REGNUM
, cpsr
);
382 /* Save a frame ID. */
383 trad_frame_set_id (this_cache
, frame_id_build (sp
, func
));
386 static struct tramp_frame arm_linux_sigreturn_tramp_frame
= {
390 { ARM_LINUX_SIGRETURN_INSTR
, -1 },
391 { TRAMP_SENTINEL_INSN
}
393 arm_linux_sigreturn_init
396 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame
= {
400 { ARM_LINUX_RT_SIGRETURN_INSTR
, -1 },
401 { TRAMP_SENTINEL_INSN
}
403 arm_linux_rt_sigreturn_init
406 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame
= {
410 { ARM_SET_R7_SIGRETURN
, -1 },
411 { ARM_EABI_SYSCALL
, -1 },
412 { TRAMP_SENTINEL_INSN
}
414 arm_linux_sigreturn_init
417 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame
= {
421 { ARM_SET_R7_RT_SIGRETURN
, -1 },
422 { ARM_EABI_SYSCALL
, -1 },
423 { TRAMP_SENTINEL_INSN
}
425 arm_linux_rt_sigreturn_init
428 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame
= {
432 { THUMB2_SET_R7_SIGRETURN1
, -1 },
433 { THUMB2_SET_R7_SIGRETURN2
, -1 },
434 { THUMB2_EABI_SYSCALL
, -1 },
435 { TRAMP_SENTINEL_INSN
}
437 arm_linux_sigreturn_init
440 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame
= {
444 { THUMB2_SET_R7_RT_SIGRETURN1
, -1 },
445 { THUMB2_SET_R7_RT_SIGRETURN2
, -1 },
446 { THUMB2_EABI_SYSCALL
, -1 },
447 { TRAMP_SENTINEL_INSN
}
449 arm_linux_rt_sigreturn_init
452 static struct tramp_frame arm_linux_restart_syscall_tramp_frame
= {
456 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
457 { ARM_LDR_PC_SP_12
, -1 },
458 { TRAMP_SENTINEL_INSN
}
460 arm_linux_restart_syscall_init
463 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame
= {
467 { ARM_OABI_SYSCALL_RESTART_SYSCALL
, -1 },
468 { ARM_LDR_PC_SP_4
, -1 },
469 { TRAMP_SENTINEL_INSN
}
471 arm_linux_restart_syscall_init
474 /* Core file and register set support. */
476 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
479 arm_linux_supply_gregset (const struct regset
*regset
,
480 struct regcache
*regcache
,
481 int regnum
, const void *gregs_buf
, size_t len
)
483 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
484 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
485 const gdb_byte
*gregs
= (const gdb_byte
*) gregs_buf
;
488 gdb_byte pc_buf
[INT_REGISTER_SIZE
];
490 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
491 if (regnum
== -1 || regnum
== regno
)
492 regcache_raw_supply (regcache
, regno
,
493 gregs
+ INT_REGISTER_SIZE
* regno
);
495 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
498 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
499 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
501 regcache_raw_supply (regcache
, ARM_PS_REGNUM
,
502 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
505 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
507 reg_pc
= extract_unsigned_integer (gregs
508 + INT_REGISTER_SIZE
* ARM_PC_REGNUM
,
509 INT_REGISTER_SIZE
, byte_order
);
510 reg_pc
= gdbarch_addr_bits_remove (gdbarch
, reg_pc
);
511 store_unsigned_integer (pc_buf
, INT_REGISTER_SIZE
, byte_order
, reg_pc
);
512 regcache_raw_supply (regcache
, ARM_PC_REGNUM
, pc_buf
);
517 arm_linux_collect_gregset (const struct regset
*regset
,
518 const struct regcache
*regcache
,
519 int regnum
, void *gregs_buf
, size_t len
)
521 gdb_byte
*gregs
= (gdb_byte
*) gregs_buf
;
524 for (regno
= ARM_A1_REGNUM
; regno
< ARM_PC_REGNUM
; regno
++)
525 if (regnum
== -1 || regnum
== regno
)
526 regcache_raw_collect (regcache
, regno
,
527 gregs
+ INT_REGISTER_SIZE
* regno
);
529 if (regnum
== ARM_PS_REGNUM
|| regnum
== -1)
532 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
533 gregs
+ INT_REGISTER_SIZE
* ARM_CPSR_GREGNUM
);
535 regcache_raw_collect (regcache
, ARM_PS_REGNUM
,
536 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
539 if (regnum
== ARM_PC_REGNUM
|| regnum
== -1)
540 regcache_raw_collect (regcache
, ARM_PC_REGNUM
,
541 gregs
+ INT_REGISTER_SIZE
* ARM_PC_REGNUM
);
544 /* Support for register format used by the NWFPE FPA emulator. */
546 #define typeNone 0x00
547 #define typeSingle 0x01
548 #define typeDouble 0x02
549 #define typeExtended 0x03
552 supply_nwfpe_register (struct regcache
*regcache
, int regno
,
553 const gdb_byte
*regs
)
555 const gdb_byte
*reg_data
;
557 gdb_byte buf
[FP_REGISTER_SIZE
];
559 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
560 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
561 memset (buf
, 0, FP_REGISTER_SIZE
);
566 memcpy (buf
, reg_data
, 4);
569 memcpy (buf
, reg_data
+ 4, 4);
570 memcpy (buf
+ 4, reg_data
, 4);
573 /* We want sign and exponent, then least significant bits,
574 then most significant. NWFPE does sign, most, least. */
575 memcpy (buf
, reg_data
, 4);
576 memcpy (buf
+ 4, reg_data
+ 8, 4);
577 memcpy (buf
+ 8, reg_data
+ 4, 4);
583 regcache_raw_supply (regcache
, regno
, buf
);
587 collect_nwfpe_register (const struct regcache
*regcache
, int regno
,
592 gdb_byte buf
[FP_REGISTER_SIZE
];
594 regcache_raw_collect (regcache
, regno
, buf
);
596 /* NOTE drow/2006-06-07: This code uses the tag already in the
597 register buffer. I've preserved that when moving the code
598 from the native file to the target file. But this doesn't
599 always make sense. */
601 reg_data
= regs
+ (regno
- ARM_F0_REGNUM
) * FP_REGISTER_SIZE
;
602 reg_tag
= regs
[(regno
- ARM_F0_REGNUM
) + NWFPE_TAGS_OFFSET
];
607 memcpy (reg_data
, buf
, 4);
610 memcpy (reg_data
, buf
+ 4, 4);
611 memcpy (reg_data
+ 4, buf
, 4);
614 memcpy (reg_data
, buf
, 4);
615 memcpy (reg_data
+ 4, buf
+ 8, 4);
616 memcpy (reg_data
+ 8, buf
+ 4, 4);
624 arm_linux_supply_nwfpe (const struct regset
*regset
,
625 struct regcache
*regcache
,
626 int regnum
, const void *regs_buf
, size_t len
)
628 const gdb_byte
*regs
= (const gdb_byte
*) regs_buf
;
631 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
632 regcache_raw_supply (regcache
, ARM_FPS_REGNUM
,
633 regs
+ NWFPE_FPSR_OFFSET
);
635 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
636 if (regnum
== -1 || regnum
== regno
)
637 supply_nwfpe_register (regcache
, regno
, regs
);
641 arm_linux_collect_nwfpe (const struct regset
*regset
,
642 const struct regcache
*regcache
,
643 int regnum
, void *regs_buf
, size_t len
)
645 gdb_byte
*regs
= (gdb_byte
*) regs_buf
;
648 for (regno
= ARM_F0_REGNUM
; regno
<= ARM_F7_REGNUM
; regno
++)
649 if (regnum
== -1 || regnum
== regno
)
650 collect_nwfpe_register (regcache
, regno
, regs
);
652 if (regnum
== ARM_FPS_REGNUM
|| regnum
== -1)
653 regcache_raw_collect (regcache
, ARM_FPS_REGNUM
,
654 regs
+ INT_REGISTER_SIZE
* ARM_FPS_REGNUM
);
657 /* Support VFP register format. */
659 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
662 arm_linux_supply_vfp (const struct regset
*regset
,
663 struct regcache
*regcache
,
664 int regnum
, const void *regs_buf
, size_t len
)
666 const gdb_byte
*regs
= (const gdb_byte
*) regs_buf
;
669 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
670 regcache_raw_supply (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
672 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
673 if (regnum
== -1 || regnum
== regno
)
674 regcache_raw_supply (regcache
, regno
,
675 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
679 arm_linux_collect_vfp (const struct regset
*regset
,
680 const struct regcache
*regcache
,
681 int regnum
, void *regs_buf
, size_t len
)
683 gdb_byte
*regs
= (gdb_byte
*) regs_buf
;
686 if (regnum
== ARM_FPSCR_REGNUM
|| regnum
== -1)
687 regcache_raw_collect (regcache
, ARM_FPSCR_REGNUM
, regs
+ 32 * 8);
689 for (regno
= ARM_D0_REGNUM
; regno
<= ARM_D31_REGNUM
; regno
++)
690 if (regnum
== -1 || regnum
== regno
)
691 regcache_raw_collect (regcache
, regno
,
692 regs
+ (regno
- ARM_D0_REGNUM
) * 8);
695 static const struct regset arm_linux_gregset
=
697 NULL
, arm_linux_supply_gregset
, arm_linux_collect_gregset
700 static const struct regset arm_linux_fpregset
=
702 NULL
, arm_linux_supply_nwfpe
, arm_linux_collect_nwfpe
705 static const struct regset arm_linux_vfpregset
=
707 NULL
, arm_linux_supply_vfp
, arm_linux_collect_vfp
710 /* Iterate over core file register note sections. */
713 arm_linux_iterate_over_regset_sections (struct gdbarch
*gdbarch
,
714 iterate_over_regset_sections_cb
*cb
,
716 const struct regcache
*regcache
)
718 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
720 cb (".reg", ARM_LINUX_SIZEOF_GREGSET
, &arm_linux_gregset
, NULL
, cb_data
);
722 if (tdep
->vfp_register_count
> 0)
723 cb (".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP
, &arm_linux_vfpregset
,
724 "VFP floating-point", cb_data
);
725 else if (tdep
->have_fpa_registers
)
726 cb (".reg2", ARM_LINUX_SIZEOF_NWFPE
, &arm_linux_fpregset
,
727 "FPA floating-point", cb_data
);
730 /* Determine target description from core file. */
732 static const struct target_desc
*
733 arm_linux_core_read_description (struct gdbarch
*gdbarch
,
734 struct target_ops
*target
,
737 CORE_ADDR arm_hwcap
= 0;
739 if (target_auxv_search (target
, AT_HWCAP
, &arm_hwcap
) != 1)
742 if (arm_hwcap
& HWCAP_VFP
)
744 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
745 Neon with VFPv3-D32. */
746 if (arm_hwcap
& HWCAP_NEON
)
747 return tdesc_arm_with_neon
;
748 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
749 return tdesc_arm_with_vfpv3
;
751 return tdesc_arm_with_vfpv2
;
758 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
759 return 1. In addition, set IS_THUMB depending on whether we
760 will return to ARM or Thumb code. Return 0 if it is not a
761 rt_sigreturn/sigreturn syscall. */
763 arm_linux_sigreturn_return_addr (struct frame_info
*frame
,
764 unsigned long svc_number
,
765 CORE_ADDR
*pc
, int *is_thumb
)
767 /* Is this a sigreturn or rt_sigreturn syscall? */
768 if (svc_number
== 119 || svc_number
== 173)
770 if (get_frame_type (frame
) == SIGTRAMP_FRAME
)
772 ULONGEST t_bit
= arm_psr_thumb_bit (frame_unwind_arch (frame
));
774 = frame_unwind_register_unsigned (frame
, ARM_PS_REGNUM
);
776 *is_thumb
= (cpsr
& t_bit
) != 0;
777 *pc
= frame_unwind_caller_pc (frame
);
784 /* Find the value of the next PC after a sigreturn or rt_sigreturn syscall
785 based on current processor state. In addition, set IS_THUMB depending
786 on whether we will return to ARM or Thumb code. */
789 arm_linux_sigreturn_next_pc (struct regcache
*regcache
,
790 unsigned long svc_number
, int *is_thumb
)
793 unsigned long sp_data
;
794 CORE_ADDR next_pc
= 0;
795 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
796 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
798 int is_sigreturn
= 0;
801 gdb_assert (svc_number
== ARM_SIGRETURN
802 || svc_number
== ARM_RT_SIGRETURN
);
804 is_sigreturn
= (svc_number
== ARM_SIGRETURN
);
805 regcache_cooked_read_unsigned (regcache
, ARM_SP_REGNUM
, &sp
);
806 sp_data
= read_memory_unsigned_integer (sp
, 4, byte_order
);
808 pc_offset
= arm_linux_sigreturn_next_pc_offset (sp
, sp_data
, svc_number
,
811 next_pc
= read_memory_unsigned_integer (sp
+ pc_offset
, 4, byte_order
);
813 /* Set IS_THUMB according the CPSR saved on the stack. */
814 cpsr
= read_memory_unsigned_integer (sp
+ pc_offset
+ 4, 4, byte_order
);
815 *is_thumb
= ((cpsr
& arm_psr_thumb_bit (gdbarch
)) != 0);
820 /* At a ptrace syscall-stop, return the syscall number. This either
821 comes from the SWI instruction (OABI) or from r7 (EABI).
823 When the function fails, it should return -1. */
826 arm_linux_get_syscall_number (struct gdbarch
*gdbarch
,
829 struct regcache
*regs
= get_thread_regcache (ptid
);
830 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
834 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
836 ULONGEST svc_number
= -1;
838 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &pc
);
839 regcache_cooked_read_unsigned (regs
, ARM_PS_REGNUM
, &cpsr
);
840 is_thumb
= (cpsr
& t_bit
) != 0;
844 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
848 enum bfd_endian byte_order_for_code
=
849 gdbarch_byte_order_for_code (gdbarch
);
851 /* PC gets incremented before the syscall-stop, so read the
852 previous instruction. */
853 unsigned long this_instr
=
854 read_memory_unsigned_integer (pc
- 4, 4, byte_order_for_code
);
856 unsigned long svc_operand
= (0x00ffffff & this_instr
);
861 svc_number
= svc_operand
- 0x900000;
866 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
874 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
,
877 CORE_ADDR next_pc
= 0;
878 int is_thumb
= arm_is_thumb (self
->regcache
);
879 ULONGEST svc_number
= 0;
880 struct gdbarch
*gdbarch
= get_regcache_arch (self
->regcache
);
884 svc_number
= regcache_raw_get_unsigned (self
->regcache
, 7);
889 struct gdbarch
*gdbarch
= get_regcache_arch (self
->regcache
);
890 enum bfd_endian byte_order_for_code
=
891 gdbarch_byte_order_for_code (gdbarch
);
892 unsigned long this_instr
=
893 read_memory_unsigned_integer (pc
, 4, byte_order_for_code
);
895 unsigned long svc_operand
= (0x00ffffff & this_instr
);
896 if (svc_operand
) /* OABI. */
898 svc_number
= svc_operand
- 0x900000;
902 svc_number
= regcache_raw_get_unsigned (self
->regcache
, 7);
908 if (svc_number
== ARM_SIGRETURN
|| svc_number
== ARM_RT_SIGRETURN
)
910 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
912 next_pc
= arm_linux_sigreturn_next_pc (self
->regcache
, svc_number
,
916 /* Addresses for calling Thumb functions have the bit 0 set. */
918 next_pc
= MAKE_THUMB_ADDR (next_pc
);
924 /* Insert a single step breakpoint at the next executed instruction. */
927 arm_linux_software_single_step (struct frame_info
*frame
)
929 struct regcache
*regcache
= get_current_regcache ();
930 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
931 struct address_space
*aspace
= get_regcache_aspace (regcache
);
932 struct arm_get_next_pcs next_pcs_ctx
;
935 VEC (CORE_ADDR
) *next_pcs
= NULL
;
936 struct cleanup
*old_chain
= make_cleanup (VEC_cleanup (CORE_ADDR
), &next_pcs
);
938 /* If the target does have hardware single step, GDB doesn't have
939 to bother software single step. */
940 if (target_can_do_single_step () == 1)
943 arm_get_next_pcs_ctor (&next_pcs_ctx
,
944 &arm_linux_get_next_pcs_ops
,
945 gdbarch_byte_order (gdbarch
),
946 gdbarch_byte_order_for_code (gdbarch
),
950 next_pcs
= arm_get_next_pcs (&next_pcs_ctx
);
952 for (i
= 0; VEC_iterate (CORE_ADDR
, next_pcs
, i
, pc
); i
++)
954 /* The Linux kernel offers some user-mode helpers in a high page. We can
955 not read this page (as of 2.6.23), and even if we could then we
956 couldn't set breakpoints in it, and even if we could then the atomic
957 operations would fail when interrupted. They are all called as
958 functions and return to the address in LR, so step to there
961 pc
= get_frame_register_unsigned (frame
, ARM_LR_REGNUM
);
963 arm_insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
966 do_cleanups (old_chain
);
971 /* Support for displaced stepping of Linux SVC instructions. */
974 arm_linux_cleanup_svc (struct gdbarch
*gdbarch
,
975 struct regcache
*regs
,
976 struct displaced_step_closure
*dsc
)
978 ULONGEST apparent_pc
;
981 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &apparent_pc
);
983 within_scratch
= (apparent_pc
>= dsc
->scratch_base
984 && apparent_pc
< (dsc
->scratch_base
985 + DISPLACED_MODIFIED_INSNS
* 4 + 4));
989 fprintf_unfiltered (gdb_stdlog
, "displaced: PC is apparently %.8lx after "
990 "SVC step ", (unsigned long) apparent_pc
);
992 fprintf_unfiltered (gdb_stdlog
, "(within scratch space)\n");
994 fprintf_unfiltered (gdb_stdlog
, "(outside scratch space)\n");
998 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
,
999 dsc
->insn_addr
+ dsc
->insn_size
, BRANCH_WRITE_PC
);
1003 arm_linux_copy_svc (struct gdbarch
*gdbarch
, struct regcache
*regs
,
1004 struct displaced_step_closure
*dsc
)
1006 CORE_ADDR return_to
= 0;
1008 struct frame_info
*frame
;
1009 unsigned int svc_number
= displaced_read_reg (regs
, dsc
, 7);
1010 int is_sigreturn
= 0;
1013 frame
= get_current_frame ();
1015 is_sigreturn
= arm_linux_sigreturn_return_addr(frame
, svc_number
,
1016 &return_to
, &is_thumb
);
1019 struct symtab_and_line sal
;
1021 if (debug_displaced
)
1022 fprintf_unfiltered (gdb_stdlog
, "displaced: found "
1023 "sigreturn/rt_sigreturn SVC call. PC in "
1025 (unsigned long) get_frame_pc (frame
));
1027 if (debug_displaced
)
1028 fprintf_unfiltered (gdb_stdlog
, "displaced: unwind pc = %lx. "
1029 "Setting momentary breakpoint.\n",
1030 (unsigned long) return_to
);
1032 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
1035 sal
= find_pc_line (return_to
, 0);
1037 sal
.section
= find_pc_overlay (return_to
);
1038 sal
.explicit_pc
= 1;
1040 frame
= get_prev_frame (frame
);
1044 inferior_thread ()->control
.step_resume_breakpoint
1045 = set_momentary_breakpoint (gdbarch
, sal
, get_frame_id (frame
),
1048 /* set_momentary_breakpoint invalidates FRAME. */
1051 /* We need to make sure we actually insert the momentary
1052 breakpoint set above. */
1053 insert_breakpoints ();
1055 else if (debug_displaced
)
1056 fprintf_unfiltered (gdb_stderr
, "displaced: couldn't find previous "
1057 "frame to set momentary breakpoint for "
1058 "sigreturn/rt_sigreturn\n");
1060 else if (debug_displaced
)
1061 fprintf_unfiltered (gdb_stdlog
, "displaced: found SVC call\n");
1063 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1064 location, else nothing.
1065 Insn: unmodified svc.
1066 Cleanup: if pc lands in scratch space, pc <- insn_addr + insn_size
1067 else leave pc alone. */
1070 dsc
->cleanup
= &arm_linux_cleanup_svc
;
1071 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1073 dsc
->wrote_to_pc
= 1;
1079 /* The following two functions implement single-stepping over calls to Linux
1080 kernel helper routines, which perform e.g. atomic operations on architecture
1081 variants which don't support them natively.
1083 When this function is called, the PC will be pointing at the kernel helper
1084 (at an address inaccessible to GDB), and r14 will point to the return
1085 address. Displaced stepping always executes code in the copy area:
1086 so, make the copy-area instruction branch back to the kernel helper (the
1087 "from" address), and make r14 point to the breakpoint in the copy area. In
1088 that way, we regain control once the kernel helper returns, and can clean
1089 up appropriately (as if we had just returned from the kernel helper as it
1090 would have been called from the non-displaced location). */
1093 cleanup_kernel_helper_return (struct gdbarch
*gdbarch
,
1094 struct regcache
*regs
,
1095 struct displaced_step_closure
*dsc
)
1097 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, dsc
->tmp
[0], CANNOT_WRITE_PC
);
1098 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, dsc
->tmp
[0], BRANCH_WRITE_PC
);
1102 arm_catch_kernel_helper_return (struct gdbarch
*gdbarch
, CORE_ADDR from
,
1103 CORE_ADDR to
, struct regcache
*regs
,
1104 struct displaced_step_closure
*dsc
)
1106 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1109 dsc
->insn_addr
= from
;
1110 dsc
->cleanup
= &cleanup_kernel_helper_return
;
1111 /* Say we wrote to the PC, else cleanup will set PC to the next
1112 instruction in the helper, which isn't helpful. */
1113 dsc
->wrote_to_pc
= 1;
1115 /* Preparation: tmp[0] <- r14
1116 r14 <- <scratch space>+4
1117 *(<scratch space>+8) <- from
1118 Insn: ldr pc, [r14, #4]
1119 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
1121 dsc
->tmp
[0] = displaced_read_reg (regs
, dsc
, ARM_LR_REGNUM
);
1122 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, (ULONGEST
) to
+ 4,
1124 write_memory_unsigned_integer (to
+ 8, 4, byte_order
, from
);
1126 dsc
->modinsn
[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
1129 /* Linux-specific displaced step instruction copying function. Detects when
1130 the program has stepped into a Linux kernel helper routine (which must be
1131 handled as a special case), falling back to arm_displaced_step_copy_insn()
1134 static struct displaced_step_closure
*
1135 arm_linux_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
1136 CORE_ADDR from
, CORE_ADDR to
,
1137 struct regcache
*regs
)
1139 struct displaced_step_closure
*dsc
= XNEW (struct displaced_step_closure
);
1141 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1142 stop at the return location. */
1143 if (from
> 0xffff0000)
1145 if (debug_displaced
)
1146 fprintf_unfiltered (gdb_stdlog
, "displaced: detected kernel helper "
1147 "at %.8lx\n", (unsigned long) from
);
1149 arm_catch_kernel_helper_return (gdbarch
, from
, to
, regs
, dsc
);
1153 /* Override the default handling of SVC instructions. */
1154 dsc
->u
.svc
.copy_svc_os
= arm_linux_copy_svc
;
1156 arm_process_displaced_insn (gdbarch
, from
, to
, regs
, dsc
);
1159 arm_displaced_init_closure (gdbarch
, from
, to
, dsc
);
1164 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1168 arm_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1170 return (*s
== '#' || *s
== '$' || isdigit (*s
) /* Literal number. */
1171 || *s
== '[' /* Register indirection or
1173 || isalpha (*s
)); /* Register value. */
1176 /* This routine is used to parse a special token in ARM's assembly.
1178 The special tokens parsed by it are:
1180 - Register displacement (e.g, [fp, #-8])
1182 It returns one if the special token has been parsed successfully,
1183 or zero if the current token is not considered special. */
1186 arm_stap_parse_special_token (struct gdbarch
*gdbarch
,
1187 struct stap_parse_info
*p
)
1191 /* Temporary holder for lookahead. */
1192 const char *tmp
= p
->arg
;
1194 /* Used to save the register name. */
1205 /* Register name. */
1206 while (isalnum (*tmp
))
1213 regname
= (char *) alloca (len
+ 2);
1216 if (isdigit (*start
))
1218 /* If we are dealing with a register whose name begins with a
1219 digit, it means we should prefix the name with the letter
1220 `r', because GDB expects this name pattern. Otherwise (e.g.,
1221 we are dealing with the register `fp'), we don't need to
1222 add such a prefix. */
1227 strncpy (regname
+ offset
, start
, len
);
1229 regname
[len
] = '\0';
1231 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1232 error (_("Invalid register name `%s' on expression `%s'."),
1233 regname
, p
->saved_arg
);
1236 tmp
= skip_spaces_const (tmp
);
1237 if (*tmp
== '#' || *tmp
== '$')
1246 displacement
= strtol (tmp
, &endp
, 10);
1249 /* Skipping last `]'. */
1253 /* The displacement. */
1254 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1255 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
1256 write_exp_elt_longcst (&p
->pstate
, displacement
);
1257 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1259 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
1261 /* The register name. */
1262 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1265 write_exp_string (&p
->pstate
, str
);
1266 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1268 write_exp_elt_opcode (&p
->pstate
, BINOP_ADD
);
1270 /* Casting to the expected type. */
1271 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1272 write_exp_elt_type (&p
->pstate
, lookup_pointer_type (p
->arg_type
));
1273 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1275 write_exp_elt_opcode (&p
->pstate
, UNOP_IND
);
1285 /* ARM process record-replay constructs: syscall, signal etc. */
1287 struct linux_record_tdep arm_linux_record_tdep
;
1289 /* arm_canonicalize_syscall maps from the native arm Linux set
1290 of syscall ids into a canonical set of syscall ids used by
1293 static enum gdb_syscall
1294 arm_canonicalize_syscall (int syscall
)
1296 enum { sys_process_vm_writev
= 377 };
1298 if (syscall
<= gdb_sys_sched_getaffinity
)
1299 return (enum gdb_syscall
) syscall
;
1300 else if (syscall
>= 243 && syscall
<= 247)
1301 return (enum gdb_syscall
) (syscall
+ 2);
1302 else if (syscall
>= 248 && syscall
<= 253)
1303 return (enum gdb_syscall
) (syscall
+ 4);
1305 return gdb_sys_no_syscall
;
1308 /* Record all registers but PC register for process-record. */
1311 arm_all_but_pc_registers_record (struct regcache
*regcache
)
1315 for (i
= 0; i
< ARM_PC_REGNUM
; i
++)
1317 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
+ i
))
1321 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1327 /* Handler for arm system call instruction recording. */
1330 arm_linux_syscall_record (struct regcache
*regcache
, unsigned long svc_number
)
1333 enum gdb_syscall syscall_gdb
;
1335 syscall_gdb
= arm_canonicalize_syscall (svc_number
);
1337 if (syscall_gdb
== gdb_sys_no_syscall
)
1339 printf_unfiltered (_("Process record and replay target doesn't "
1340 "support syscall number %s\n"),
1341 plongest (svc_number
));
1345 if (syscall_gdb
== gdb_sys_sigreturn
1346 || syscall_gdb
== gdb_sys_rt_sigreturn
)
1348 if (arm_all_but_pc_registers_record (regcache
))
1353 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1354 &arm_linux_record_tdep
);
1358 /* Record the return value of the system call. */
1359 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
))
1362 if (record_full_arch_list_add_reg (regcache
, ARM_LR_REGNUM
))
1365 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1371 /* Implement the skip_trampoline_code gdbarch method. */
1374 arm_linux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1376 CORE_ADDR target_pc
= arm_skip_stub (frame
, pc
);
1381 return find_solib_trampoline_target (frame
, pc
);
1385 arm_linux_init_abi (struct gdbarch_info info
,
1386 struct gdbarch
*gdbarch
)
1388 static const char *const stap_integer_prefixes
[] = { "#", "$", "", NULL
};
1389 static const char *const stap_register_prefixes
[] = { "r", NULL
};
1390 static const char *const stap_register_indirection_prefixes
[] = { "[",
1392 static const char *const stap_register_indirection_suffixes
[] = { "]",
1394 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1396 linux_init_abi (info
, gdbarch
);
1398 tdep
->lowest_pc
= 0x8000;
1399 if (info
.byte_order_for_code
== BFD_ENDIAN_BIG
)
1401 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1402 tdep
->arm_breakpoint
= eabi_linux_arm_be_breakpoint
;
1404 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
1405 tdep
->thumb_breakpoint
= arm_linux_thumb_be_breakpoint
;
1406 tdep
->thumb2_breakpoint
= arm_linux_thumb2_be_breakpoint
;
1410 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1411 tdep
->arm_breakpoint
= eabi_linux_arm_le_breakpoint
;
1413 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
1414 tdep
->thumb_breakpoint
= arm_linux_thumb_le_breakpoint
;
1415 tdep
->thumb2_breakpoint
= arm_linux_thumb2_le_breakpoint
;
1417 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
1418 tdep
->thumb_breakpoint_size
= sizeof (arm_linux_thumb_le_breakpoint
);
1419 tdep
->thumb2_breakpoint_size
= sizeof (arm_linux_thumb2_le_breakpoint
);
1421 if (tdep
->fp_model
== ARM_FLOAT_AUTO
)
1422 tdep
->fp_model
= ARM_FLOAT_FPA
;
1424 switch (tdep
->fp_model
)
1427 tdep
->jb_pc
= ARM_LINUX_JB_PC_FPA
;
1429 case ARM_FLOAT_SOFT_FPA
:
1430 case ARM_FLOAT_SOFT_VFP
:
1432 tdep
->jb_pc
= ARM_LINUX_JB_PC_EABI
;
1436 (__FILE__
, __LINE__
,
1437 _("arm_linux_init_abi: Floating point model not supported"));
1440 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
1442 set_solib_svr4_fetch_link_map_offsets
1443 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1445 /* Single stepping. */
1446 set_gdbarch_software_single_step (gdbarch
, arm_linux_software_single_step
);
1448 /* Shared library handling. */
1449 set_gdbarch_skip_trampoline_code (gdbarch
, arm_linux_skip_trampoline_code
);
1450 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
1452 /* Enable TLS support. */
1453 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1454 svr4_fetch_objfile_link_map
);
1456 tramp_frame_prepend_unwinder (gdbarch
,
1457 &arm_linux_sigreturn_tramp_frame
);
1458 tramp_frame_prepend_unwinder (gdbarch
,
1459 &arm_linux_rt_sigreturn_tramp_frame
);
1460 tramp_frame_prepend_unwinder (gdbarch
,
1461 &arm_eabi_linux_sigreturn_tramp_frame
);
1462 tramp_frame_prepend_unwinder (gdbarch
,
1463 &arm_eabi_linux_rt_sigreturn_tramp_frame
);
1464 tramp_frame_prepend_unwinder (gdbarch
,
1465 &thumb2_eabi_linux_sigreturn_tramp_frame
);
1466 tramp_frame_prepend_unwinder (gdbarch
,
1467 &thumb2_eabi_linux_rt_sigreturn_tramp_frame
);
1468 tramp_frame_prepend_unwinder (gdbarch
,
1469 &arm_linux_restart_syscall_tramp_frame
);
1470 tramp_frame_prepend_unwinder (gdbarch
,
1471 &arm_kernel_linux_restart_syscall_tramp_frame
);
1473 /* Core file support. */
1474 set_gdbarch_iterate_over_regset_sections
1475 (gdbarch
, arm_linux_iterate_over_regset_sections
);
1476 set_gdbarch_core_read_description (gdbarch
, arm_linux_core_read_description
);
1478 /* Displaced stepping. */
1479 set_gdbarch_displaced_step_copy_insn (gdbarch
,
1480 arm_linux_displaced_step_copy_insn
);
1481 set_gdbarch_displaced_step_fixup (gdbarch
, arm_displaced_step_fixup
);
1482 set_gdbarch_displaced_step_free_closure (gdbarch
,
1483 simple_displaced_step_free_closure
);
1484 set_gdbarch_displaced_step_location (gdbarch
, linux_displaced_step_location
);
1486 /* Reversible debugging, process record. */
1487 set_gdbarch_process_record (gdbarch
, arm_process_record
);
1489 /* SystemTap functions. */
1490 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
1491 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
1492 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
1493 stap_register_indirection_prefixes
);
1494 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
1495 stap_register_indirection_suffixes
);
1496 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
1497 set_gdbarch_stap_is_single_operand (gdbarch
, arm_stap_is_single_operand
);
1498 set_gdbarch_stap_parse_special_token (gdbarch
,
1499 arm_stap_parse_special_token
);
1501 /* `catch syscall' */
1502 set_xml_syscall_file_name (gdbarch
, "syscalls/arm-linux.xml");
1503 set_gdbarch_get_syscall_number (gdbarch
, arm_linux_get_syscall_number
);
1505 /* Syscall record. */
1506 tdep
->arm_syscall_record
= arm_linux_syscall_record
;
1508 /* Initialize the arm_linux_record_tdep. */
1509 /* These values are the size of the type that will be used in a system
1510 call. They are obtained from Linux Kernel source. */
1511 arm_linux_record_tdep
.size_pointer
1512 = gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1513 arm_linux_record_tdep
.size__old_kernel_stat
= 32;
1514 arm_linux_record_tdep
.size_tms
= 16;
1515 arm_linux_record_tdep
.size_loff_t
= 8;
1516 arm_linux_record_tdep
.size_flock
= 16;
1517 arm_linux_record_tdep
.size_oldold_utsname
= 45;
1518 arm_linux_record_tdep
.size_ustat
= 20;
1519 arm_linux_record_tdep
.size_old_sigaction
= 16;
1520 arm_linux_record_tdep
.size_old_sigset_t
= 4;
1521 arm_linux_record_tdep
.size_rlimit
= 8;
1522 arm_linux_record_tdep
.size_rusage
= 72;
1523 arm_linux_record_tdep
.size_timeval
= 8;
1524 arm_linux_record_tdep
.size_timezone
= 8;
1525 arm_linux_record_tdep
.size_old_gid_t
= 2;
1526 arm_linux_record_tdep
.size_old_uid_t
= 2;
1527 arm_linux_record_tdep
.size_fd_set
= 128;
1528 arm_linux_record_tdep
.size_old_dirent
= 268;
1529 arm_linux_record_tdep
.size_statfs
= 64;
1530 arm_linux_record_tdep
.size_statfs64
= 84;
1531 arm_linux_record_tdep
.size_sockaddr
= 16;
1532 arm_linux_record_tdep
.size_int
1533 = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
1534 arm_linux_record_tdep
.size_long
1535 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1536 arm_linux_record_tdep
.size_ulong
1537 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1538 arm_linux_record_tdep
.size_msghdr
= 28;
1539 arm_linux_record_tdep
.size_itimerval
= 16;
1540 arm_linux_record_tdep
.size_stat
= 88;
1541 arm_linux_record_tdep
.size_old_utsname
= 325;
1542 arm_linux_record_tdep
.size_sysinfo
= 64;
1543 arm_linux_record_tdep
.size_msqid_ds
= 88;
1544 arm_linux_record_tdep
.size_shmid_ds
= 84;
1545 arm_linux_record_tdep
.size_new_utsname
= 390;
1546 arm_linux_record_tdep
.size_timex
= 128;
1547 arm_linux_record_tdep
.size_mem_dqinfo
= 24;
1548 arm_linux_record_tdep
.size_if_dqblk
= 68;
1549 arm_linux_record_tdep
.size_fs_quota_stat
= 68;
1550 arm_linux_record_tdep
.size_timespec
= 8;
1551 arm_linux_record_tdep
.size_pollfd
= 8;
1552 arm_linux_record_tdep
.size_NFS_FHSIZE
= 32;
1553 arm_linux_record_tdep
.size_knfsd_fh
= 132;
1554 arm_linux_record_tdep
.size_TASK_COMM_LEN
= 16;
1555 arm_linux_record_tdep
.size_sigaction
= 20;
1556 arm_linux_record_tdep
.size_sigset_t
= 8;
1557 arm_linux_record_tdep
.size_siginfo_t
= 128;
1558 arm_linux_record_tdep
.size_cap_user_data_t
= 12;
1559 arm_linux_record_tdep
.size_stack_t
= 12;
1560 arm_linux_record_tdep
.size_off_t
= arm_linux_record_tdep
.size_long
;
1561 arm_linux_record_tdep
.size_stat64
= 96;
1562 arm_linux_record_tdep
.size_gid_t
= 4;
1563 arm_linux_record_tdep
.size_uid_t
= 4;
1564 arm_linux_record_tdep
.size_PAGE_SIZE
= 4096;
1565 arm_linux_record_tdep
.size_flock64
= 24;
1566 arm_linux_record_tdep
.size_user_desc
= 16;
1567 arm_linux_record_tdep
.size_io_event
= 32;
1568 arm_linux_record_tdep
.size_iocb
= 64;
1569 arm_linux_record_tdep
.size_epoll_event
= 12;
1570 arm_linux_record_tdep
.size_itimerspec
1571 = arm_linux_record_tdep
.size_timespec
* 2;
1572 arm_linux_record_tdep
.size_mq_attr
= 32;
1573 arm_linux_record_tdep
.size_termios
= 36;
1574 arm_linux_record_tdep
.size_termios2
= 44;
1575 arm_linux_record_tdep
.size_pid_t
= 4;
1576 arm_linux_record_tdep
.size_winsize
= 8;
1577 arm_linux_record_tdep
.size_serial_struct
= 60;
1578 arm_linux_record_tdep
.size_serial_icounter_struct
= 80;
1579 arm_linux_record_tdep
.size_hayes_esp_config
= 12;
1580 arm_linux_record_tdep
.size_size_t
= 4;
1581 arm_linux_record_tdep
.size_iovec
= 8;
1582 arm_linux_record_tdep
.size_time_t
= 4;
1584 /* These values are the second argument of system call "sys_ioctl".
1585 They are obtained from Linux Kernel source. */
1586 arm_linux_record_tdep
.ioctl_TCGETS
= 0x5401;
1587 arm_linux_record_tdep
.ioctl_TCSETS
= 0x5402;
1588 arm_linux_record_tdep
.ioctl_TCSETSW
= 0x5403;
1589 arm_linux_record_tdep
.ioctl_TCSETSF
= 0x5404;
1590 arm_linux_record_tdep
.ioctl_TCGETA
= 0x5405;
1591 arm_linux_record_tdep
.ioctl_TCSETA
= 0x5406;
1592 arm_linux_record_tdep
.ioctl_TCSETAW
= 0x5407;
1593 arm_linux_record_tdep
.ioctl_TCSETAF
= 0x5408;
1594 arm_linux_record_tdep
.ioctl_TCSBRK
= 0x5409;
1595 arm_linux_record_tdep
.ioctl_TCXONC
= 0x540a;
1596 arm_linux_record_tdep
.ioctl_TCFLSH
= 0x540b;
1597 arm_linux_record_tdep
.ioctl_TIOCEXCL
= 0x540c;
1598 arm_linux_record_tdep
.ioctl_TIOCNXCL
= 0x540d;
1599 arm_linux_record_tdep
.ioctl_TIOCSCTTY
= 0x540e;
1600 arm_linux_record_tdep
.ioctl_TIOCGPGRP
= 0x540f;
1601 arm_linux_record_tdep
.ioctl_TIOCSPGRP
= 0x5410;
1602 arm_linux_record_tdep
.ioctl_TIOCOUTQ
= 0x5411;
1603 arm_linux_record_tdep
.ioctl_TIOCSTI
= 0x5412;
1604 arm_linux_record_tdep
.ioctl_TIOCGWINSZ
= 0x5413;
1605 arm_linux_record_tdep
.ioctl_TIOCSWINSZ
= 0x5414;
1606 arm_linux_record_tdep
.ioctl_TIOCMGET
= 0x5415;
1607 arm_linux_record_tdep
.ioctl_TIOCMBIS
= 0x5416;
1608 arm_linux_record_tdep
.ioctl_TIOCMBIC
= 0x5417;
1609 arm_linux_record_tdep
.ioctl_TIOCMSET
= 0x5418;
1610 arm_linux_record_tdep
.ioctl_TIOCGSOFTCAR
= 0x5419;
1611 arm_linux_record_tdep
.ioctl_TIOCSSOFTCAR
= 0x541a;
1612 arm_linux_record_tdep
.ioctl_FIONREAD
= 0x541b;
1613 arm_linux_record_tdep
.ioctl_TIOCINQ
= arm_linux_record_tdep
.ioctl_FIONREAD
;
1614 arm_linux_record_tdep
.ioctl_TIOCLINUX
= 0x541c;
1615 arm_linux_record_tdep
.ioctl_TIOCCONS
= 0x541d;
1616 arm_linux_record_tdep
.ioctl_TIOCGSERIAL
= 0x541e;
1617 arm_linux_record_tdep
.ioctl_TIOCSSERIAL
= 0x541f;
1618 arm_linux_record_tdep
.ioctl_TIOCPKT
= 0x5420;
1619 arm_linux_record_tdep
.ioctl_FIONBIO
= 0x5421;
1620 arm_linux_record_tdep
.ioctl_TIOCNOTTY
= 0x5422;
1621 arm_linux_record_tdep
.ioctl_TIOCSETD
= 0x5423;
1622 arm_linux_record_tdep
.ioctl_TIOCGETD
= 0x5424;
1623 arm_linux_record_tdep
.ioctl_TCSBRKP
= 0x5425;
1624 arm_linux_record_tdep
.ioctl_TIOCTTYGSTRUCT
= 0x5426;
1625 arm_linux_record_tdep
.ioctl_TIOCSBRK
= 0x5427;
1626 arm_linux_record_tdep
.ioctl_TIOCCBRK
= 0x5428;
1627 arm_linux_record_tdep
.ioctl_TIOCGSID
= 0x5429;
1628 arm_linux_record_tdep
.ioctl_TCGETS2
= 0x802c542a;
1629 arm_linux_record_tdep
.ioctl_TCSETS2
= 0x402c542b;
1630 arm_linux_record_tdep
.ioctl_TCSETSW2
= 0x402c542c;
1631 arm_linux_record_tdep
.ioctl_TCSETSF2
= 0x402c542d;
1632 arm_linux_record_tdep
.ioctl_TIOCGPTN
= 0x80045430;
1633 arm_linux_record_tdep
.ioctl_TIOCSPTLCK
= 0x40045431;
1634 arm_linux_record_tdep
.ioctl_FIONCLEX
= 0x5450;
1635 arm_linux_record_tdep
.ioctl_FIOCLEX
= 0x5451;
1636 arm_linux_record_tdep
.ioctl_FIOASYNC
= 0x5452;
1637 arm_linux_record_tdep
.ioctl_TIOCSERCONFIG
= 0x5453;
1638 arm_linux_record_tdep
.ioctl_TIOCSERGWILD
= 0x5454;
1639 arm_linux_record_tdep
.ioctl_TIOCSERSWILD
= 0x5455;
1640 arm_linux_record_tdep
.ioctl_TIOCGLCKTRMIOS
= 0x5456;
1641 arm_linux_record_tdep
.ioctl_TIOCSLCKTRMIOS
= 0x5457;
1642 arm_linux_record_tdep
.ioctl_TIOCSERGSTRUCT
= 0x5458;
1643 arm_linux_record_tdep
.ioctl_TIOCSERGETLSR
= 0x5459;
1644 arm_linux_record_tdep
.ioctl_TIOCSERGETMULTI
= 0x545a;
1645 arm_linux_record_tdep
.ioctl_TIOCSERSETMULTI
= 0x545b;
1646 arm_linux_record_tdep
.ioctl_TIOCMIWAIT
= 0x545c;
1647 arm_linux_record_tdep
.ioctl_TIOCGICOUNT
= 0x545d;
1648 arm_linux_record_tdep
.ioctl_TIOCGHAYESESP
= 0x545e;
1649 arm_linux_record_tdep
.ioctl_TIOCSHAYESESP
= 0x545f;
1650 arm_linux_record_tdep
.ioctl_FIOQSIZE
= 0x5460;
1652 /* These values are the second argument of system call "sys_fcntl"
1653 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1654 arm_linux_record_tdep
.fcntl_F_GETLK
= 5;
1655 arm_linux_record_tdep
.fcntl_F_GETLK64
= 12;
1656 arm_linux_record_tdep
.fcntl_F_SETLK64
= 13;
1657 arm_linux_record_tdep
.fcntl_F_SETLKW64
= 14;
1659 arm_linux_record_tdep
.arg1
= ARM_A1_REGNUM
+ 1;
1660 arm_linux_record_tdep
.arg2
= ARM_A1_REGNUM
+ 2;
1661 arm_linux_record_tdep
.arg3
= ARM_A1_REGNUM
+ 3;
1662 arm_linux_record_tdep
.arg4
= ARM_A1_REGNUM
+ 3;
1665 /* Provide a prototype to silence -Wmissing-prototypes. */
1666 extern initialize_file_ftype _initialize_arm_linux_tdep
;
1669 _initialize_arm_linux_tdep (void)
1671 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,
1672 arm_linux_init_abi
);