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
);
271 /* Operation function pointers for get_next_pcs. */
272 static struct arm_get_next_pcs_ops arm_linux_get_next_pcs_ops
= {
273 arm_get_next_pcs_read_memory_unsigned_integer
,
274 arm_linux_get_next_pcs_syscall_next_pc
,
275 arm_get_next_pcs_addr_bits_remove
,
276 arm_get_next_pcs_is_thumb
,
277 arm_linux_get_next_pcs_fixup
,
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
);
833 ULONGEST t_bit
= arm_psr_thumb_bit (gdbarch
);
835 ULONGEST svc_number
= -1;
837 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &pc
);
838 regcache_cooked_read_unsigned (regs
, ARM_PS_REGNUM
, &cpsr
);
839 is_thumb
= (cpsr
& t_bit
) != 0;
843 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
847 enum bfd_endian byte_order_for_code
=
848 gdbarch_byte_order_for_code (gdbarch
);
850 /* PC gets incremented before the syscall-stop, so read the
851 previous instruction. */
852 unsigned long this_instr
=
853 read_memory_unsigned_integer (pc
- 4, 4, byte_order_for_code
);
855 unsigned long svc_operand
= (0x00ffffff & this_instr
);
860 svc_number
= svc_operand
- 0x900000;
865 regcache_cooked_read_unsigned (regs
, 7, &svc_number
);
873 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs
*self
)
875 CORE_ADDR next_pc
= 0;
876 CORE_ADDR pc
= regcache_read_pc (self
->regcache
);
877 int is_thumb
= arm_is_thumb (self
->regcache
);
878 ULONGEST svc_number
= 0;
882 svc_number
= regcache_raw_get_unsigned (self
->regcache
, 7);
887 struct gdbarch
*gdbarch
= get_regcache_arch (self
->regcache
);
888 enum bfd_endian byte_order_for_code
=
889 gdbarch_byte_order_for_code (gdbarch
);
890 unsigned long this_instr
=
891 read_memory_unsigned_integer (pc
, 4, byte_order_for_code
);
893 unsigned long svc_operand
= (0x00ffffff & this_instr
);
894 if (svc_operand
) /* OABI. */
896 svc_number
= svc_operand
- 0x900000;
900 svc_number
= regcache_raw_get_unsigned (self
->regcache
, 7);
906 if (svc_number
== ARM_SIGRETURN
|| svc_number
== ARM_RT_SIGRETURN
)
908 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
910 next_pc
= arm_linux_sigreturn_next_pc (self
->regcache
, svc_number
,
914 /* Addresses for calling Thumb functions have the bit 0 set. */
916 next_pc
= MAKE_THUMB_ADDR (next_pc
);
922 /* Insert a single step breakpoint at the next executed instruction. */
925 arm_linux_software_single_step (struct frame_info
*frame
)
927 struct regcache
*regcache
= get_current_regcache ();
928 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
929 struct address_space
*aspace
= get_regcache_aspace (regcache
);
930 struct arm_get_next_pcs next_pcs_ctx
;
933 VEC (CORE_ADDR
) *next_pcs
= NULL
;
934 struct cleanup
*old_chain
;
936 /* If the target does have hardware single step, GDB doesn't have
937 to bother software single step. */
938 if (target_can_do_single_step () == 1)
941 old_chain
= make_cleanup (VEC_cleanup (CORE_ADDR
), &next_pcs
);
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 pc
= gdbarch_addr_bits_remove (gdbarch
, pc
);
955 VEC_replace (CORE_ADDR
, next_pcs
, i
, pc
);
958 for (i
= 0; VEC_iterate (CORE_ADDR
, next_pcs
, i
, pc
); i
++)
959 insert_single_step_breakpoint (gdbarch
, aspace
, pc
);
961 do_cleanups (old_chain
);
966 /* Support for displaced stepping of Linux SVC instructions. */
969 arm_linux_cleanup_svc (struct gdbarch
*gdbarch
,
970 struct regcache
*regs
,
971 struct displaced_step_closure
*dsc
)
973 ULONGEST apparent_pc
;
976 regcache_cooked_read_unsigned (regs
, ARM_PC_REGNUM
, &apparent_pc
);
978 within_scratch
= (apparent_pc
>= dsc
->scratch_base
979 && apparent_pc
< (dsc
->scratch_base
980 + DISPLACED_MODIFIED_INSNS
* 4 + 4));
984 fprintf_unfiltered (gdb_stdlog
, "displaced: PC is apparently %.8lx after "
985 "SVC step ", (unsigned long) apparent_pc
);
987 fprintf_unfiltered (gdb_stdlog
, "(within scratch space)\n");
989 fprintf_unfiltered (gdb_stdlog
, "(outside scratch space)\n");
993 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
,
994 dsc
->insn_addr
+ dsc
->insn_size
, BRANCH_WRITE_PC
);
998 arm_linux_copy_svc (struct gdbarch
*gdbarch
, struct regcache
*regs
,
999 struct displaced_step_closure
*dsc
)
1001 CORE_ADDR return_to
= 0;
1003 struct frame_info
*frame
;
1004 unsigned int svc_number
= displaced_read_reg (regs
, dsc
, 7);
1005 int is_sigreturn
= 0;
1008 frame
= get_current_frame ();
1010 is_sigreturn
= arm_linux_sigreturn_return_addr(frame
, svc_number
,
1011 &return_to
, &is_thumb
);
1014 struct symtab_and_line sal
;
1016 if (debug_displaced
)
1017 fprintf_unfiltered (gdb_stdlog
, "displaced: found "
1018 "sigreturn/rt_sigreturn SVC call. PC in "
1020 (unsigned long) get_frame_pc (frame
));
1022 if (debug_displaced
)
1023 fprintf_unfiltered (gdb_stdlog
, "displaced: unwind pc = %lx. "
1024 "Setting momentary breakpoint.\n",
1025 (unsigned long) return_to
);
1027 gdb_assert (inferior_thread ()->control
.step_resume_breakpoint
1030 sal
= find_pc_line (return_to
, 0);
1032 sal
.section
= find_pc_overlay (return_to
);
1033 sal
.explicit_pc
= 1;
1035 frame
= get_prev_frame (frame
);
1039 inferior_thread ()->control
.step_resume_breakpoint
1040 = set_momentary_breakpoint (gdbarch
, sal
, get_frame_id (frame
),
1043 /* set_momentary_breakpoint invalidates FRAME. */
1046 /* We need to make sure we actually insert the momentary
1047 breakpoint set above. */
1048 insert_breakpoints ();
1050 else if (debug_displaced
)
1051 fprintf_unfiltered (gdb_stderr
, "displaced: couldn't find previous "
1052 "frame to set momentary breakpoint for "
1053 "sigreturn/rt_sigreturn\n");
1055 else if (debug_displaced
)
1056 fprintf_unfiltered (gdb_stdlog
, "displaced: found SVC call\n");
1058 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1059 location, else nothing.
1060 Insn: unmodified svc.
1061 Cleanup: if pc lands in scratch space, pc <- insn_addr + insn_size
1062 else leave pc alone. */
1065 dsc
->cleanup
= &arm_linux_cleanup_svc
;
1066 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1068 dsc
->wrote_to_pc
= 1;
1074 /* The following two functions implement single-stepping over calls to Linux
1075 kernel helper routines, which perform e.g. atomic operations on architecture
1076 variants which don't support them natively.
1078 When this function is called, the PC will be pointing at the kernel helper
1079 (at an address inaccessible to GDB), and r14 will point to the return
1080 address. Displaced stepping always executes code in the copy area:
1081 so, make the copy-area instruction branch back to the kernel helper (the
1082 "from" address), and make r14 point to the breakpoint in the copy area. In
1083 that way, we regain control once the kernel helper returns, and can clean
1084 up appropriately (as if we had just returned from the kernel helper as it
1085 would have been called from the non-displaced location). */
1088 cleanup_kernel_helper_return (struct gdbarch
*gdbarch
,
1089 struct regcache
*regs
,
1090 struct displaced_step_closure
*dsc
)
1092 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, dsc
->tmp
[0], CANNOT_WRITE_PC
);
1093 displaced_write_reg (regs
, dsc
, ARM_PC_REGNUM
, dsc
->tmp
[0], BRANCH_WRITE_PC
);
1097 arm_catch_kernel_helper_return (struct gdbarch
*gdbarch
, CORE_ADDR from
,
1098 CORE_ADDR to
, struct regcache
*regs
,
1099 struct displaced_step_closure
*dsc
)
1101 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1104 dsc
->insn_addr
= from
;
1105 dsc
->cleanup
= &cleanup_kernel_helper_return
;
1106 /* Say we wrote to the PC, else cleanup will set PC to the next
1107 instruction in the helper, which isn't helpful. */
1108 dsc
->wrote_to_pc
= 1;
1110 /* Preparation: tmp[0] <- r14
1111 r14 <- <scratch space>+4
1112 *(<scratch space>+8) <- from
1113 Insn: ldr pc, [r14, #4]
1114 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
1116 dsc
->tmp
[0] = displaced_read_reg (regs
, dsc
, ARM_LR_REGNUM
);
1117 displaced_write_reg (regs
, dsc
, ARM_LR_REGNUM
, (ULONGEST
) to
+ 4,
1119 write_memory_unsigned_integer (to
+ 8, 4, byte_order
, from
);
1121 dsc
->modinsn
[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
1124 /* Linux-specific displaced step instruction copying function. Detects when
1125 the program has stepped into a Linux kernel helper routine (which must be
1126 handled as a special case). */
1128 static struct displaced_step_closure
*
1129 arm_linux_displaced_step_copy_insn (struct gdbarch
*gdbarch
,
1130 CORE_ADDR from
, CORE_ADDR to
,
1131 struct regcache
*regs
)
1133 struct displaced_step_closure
*dsc
= XNEW (struct displaced_step_closure
);
1135 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1136 stop at the return location. */
1137 if (from
> 0xffff0000)
1139 if (debug_displaced
)
1140 fprintf_unfiltered (gdb_stdlog
, "displaced: detected kernel helper "
1141 "at %.8lx\n", (unsigned long) from
);
1143 arm_catch_kernel_helper_return (gdbarch
, from
, to
, regs
, dsc
);
1147 /* Override the default handling of SVC instructions. */
1148 dsc
->u
.svc
.copy_svc_os
= arm_linux_copy_svc
;
1150 arm_process_displaced_insn (gdbarch
, from
, to
, regs
, dsc
);
1153 arm_displaced_init_closure (gdbarch
, from
, to
, dsc
);
1158 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1162 arm_stap_is_single_operand (struct gdbarch
*gdbarch
, const char *s
)
1164 return (*s
== '#' || *s
== '$' || isdigit (*s
) /* Literal number. */
1165 || *s
== '[' /* Register indirection or
1167 || isalpha (*s
)); /* Register value. */
1170 /* This routine is used to parse a special token in ARM's assembly.
1172 The special tokens parsed by it are:
1174 - Register displacement (e.g, [fp, #-8])
1176 It returns one if the special token has been parsed successfully,
1177 or zero if the current token is not considered special. */
1180 arm_stap_parse_special_token (struct gdbarch
*gdbarch
,
1181 struct stap_parse_info
*p
)
1185 /* Temporary holder for lookahead. */
1186 const char *tmp
= p
->arg
;
1188 /* Used to save the register name. */
1199 /* Register name. */
1200 while (isalnum (*tmp
))
1207 regname
= (char *) alloca (len
+ 2);
1210 if (isdigit (*start
))
1212 /* If we are dealing with a register whose name begins with a
1213 digit, it means we should prefix the name with the letter
1214 `r', because GDB expects this name pattern. Otherwise (e.g.,
1215 we are dealing with the register `fp'), we don't need to
1216 add such a prefix. */
1221 strncpy (regname
+ offset
, start
, len
);
1223 regname
[len
] = '\0';
1225 if (user_reg_map_name_to_regnum (gdbarch
, regname
, len
) == -1)
1226 error (_("Invalid register name `%s' on expression `%s'."),
1227 regname
, p
->saved_arg
);
1230 tmp
= skip_spaces_const (tmp
);
1231 if (*tmp
== '#' || *tmp
== '$')
1240 displacement
= strtol (tmp
, &endp
, 10);
1243 /* Skipping last `]'. */
1247 /* The displacement. */
1248 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1249 write_exp_elt_type (&p
->pstate
, builtin_type (gdbarch
)->builtin_long
);
1250 write_exp_elt_longcst (&p
->pstate
, displacement
);
1251 write_exp_elt_opcode (&p
->pstate
, OP_LONG
);
1253 write_exp_elt_opcode (&p
->pstate
, UNOP_NEG
);
1255 /* The register name. */
1256 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1259 write_exp_string (&p
->pstate
, str
);
1260 write_exp_elt_opcode (&p
->pstate
, OP_REGISTER
);
1262 write_exp_elt_opcode (&p
->pstate
, BINOP_ADD
);
1264 /* Casting to the expected type. */
1265 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1266 write_exp_elt_type (&p
->pstate
, lookup_pointer_type (p
->arg_type
));
1267 write_exp_elt_opcode (&p
->pstate
, UNOP_CAST
);
1269 write_exp_elt_opcode (&p
->pstate
, UNOP_IND
);
1279 /* ARM process record-replay constructs: syscall, signal etc. */
1281 struct linux_record_tdep arm_linux_record_tdep
;
1283 /* arm_canonicalize_syscall maps from the native arm Linux set
1284 of syscall ids into a canonical set of syscall ids used by
1287 static enum gdb_syscall
1288 arm_canonicalize_syscall (int syscall
)
1292 case 0: return gdb_sys_restart_syscall
;
1293 case 1: return gdb_sys_exit
;
1294 case 2: return gdb_sys_fork
;
1295 case 3: return gdb_sys_read
;
1296 case 4: return gdb_sys_write
;
1297 case 5: return gdb_sys_open
;
1298 case 6: return gdb_sys_close
;
1299 case 8: return gdb_sys_creat
;
1300 case 9: return gdb_sys_link
;
1301 case 10: return gdb_sys_unlink
;
1302 case 11: return gdb_sys_execve
;
1303 case 12: return gdb_sys_chdir
;
1304 case 13: return gdb_sys_time
;
1305 case 14: return gdb_sys_mknod
;
1306 case 15: return gdb_sys_chmod
;
1307 case 16: return gdb_sys_lchown16
;
1308 case 19: return gdb_sys_lseek
;
1309 case 20: return gdb_sys_getpid
;
1310 case 21: return gdb_sys_mount
;
1311 case 22: return gdb_sys_oldumount
;
1312 case 23: return gdb_sys_setuid16
;
1313 case 24: return gdb_sys_getuid16
;
1314 case 25: return gdb_sys_stime
;
1315 case 26: return gdb_sys_ptrace
;
1316 case 27: return gdb_sys_alarm
;
1317 case 29: return gdb_sys_pause
;
1318 case 30: return gdb_sys_utime
;
1319 case 33: return gdb_sys_access
;
1320 case 34: return gdb_sys_nice
;
1321 case 36: return gdb_sys_sync
;
1322 case 37: return gdb_sys_kill
;
1323 case 38: return gdb_sys_rename
;
1324 case 39: return gdb_sys_mkdir
;
1325 case 40: return gdb_sys_rmdir
;
1326 case 41: return gdb_sys_dup
;
1327 case 42: return gdb_sys_pipe
;
1328 case 43: return gdb_sys_times
;
1329 case 45: return gdb_sys_brk
;
1330 case 46: return gdb_sys_setgid16
;
1331 case 47: return gdb_sys_getgid16
;
1332 case 49: return gdb_sys_geteuid16
;
1333 case 50: return gdb_sys_getegid16
;
1334 case 51: return gdb_sys_acct
;
1335 case 52: return gdb_sys_umount
;
1336 case 54: return gdb_sys_ioctl
;
1337 case 55: return gdb_sys_fcntl
;
1338 case 57: return gdb_sys_setpgid
;
1339 case 60: return gdb_sys_umask
;
1340 case 61: return gdb_sys_chroot
;
1341 case 62: return gdb_sys_ustat
;
1342 case 63: return gdb_sys_dup2
;
1343 case 64: return gdb_sys_getppid
;
1344 case 65: return gdb_sys_getpgrp
;
1345 case 66: return gdb_sys_setsid
;
1346 case 67: return gdb_sys_sigaction
;
1347 case 70: return gdb_sys_setreuid16
;
1348 case 71: return gdb_sys_setregid16
;
1349 case 72: return gdb_sys_sigsuspend
;
1350 case 73: return gdb_sys_sigpending
;
1351 case 74: return gdb_sys_sethostname
;
1352 case 75: return gdb_sys_setrlimit
;
1353 case 76: return gdb_sys_getrlimit
;
1354 case 77: return gdb_sys_getrusage
;
1355 case 78: return gdb_sys_gettimeofday
;
1356 case 79: return gdb_sys_settimeofday
;
1357 case 80: return gdb_sys_getgroups16
;
1358 case 81: return gdb_sys_setgroups16
;
1359 case 82: return gdb_sys_select
;
1360 case 83: return gdb_sys_symlink
;
1361 case 85: return gdb_sys_readlink
;
1362 case 86: return gdb_sys_uselib
;
1363 case 87: return gdb_sys_swapon
;
1364 case 88: return gdb_sys_reboot
;
1365 case 89: return gdb_old_readdir
;
1366 case 90: return gdb_old_mmap
;
1367 case 91: return gdb_sys_munmap
;
1368 case 92: return gdb_sys_truncate
;
1369 case 93: return gdb_sys_ftruncate
;
1370 case 94: return gdb_sys_fchmod
;
1371 case 95: return gdb_sys_fchown16
;
1372 case 96: return gdb_sys_getpriority
;
1373 case 97: return gdb_sys_setpriority
;
1374 case 99: return gdb_sys_statfs
;
1375 case 100: return gdb_sys_fstatfs
;
1376 case 102: return gdb_sys_socketcall
;
1377 case 103: return gdb_sys_syslog
;
1378 case 104: return gdb_sys_setitimer
;
1379 case 105: return gdb_sys_getitimer
;
1380 case 106: return gdb_sys_stat
;
1381 case 107: return gdb_sys_lstat
;
1382 case 108: return gdb_sys_fstat
;
1383 case 111: return gdb_sys_vhangup
;
1384 case 113: /* sys_syscall */
1385 return gdb_sys_no_syscall
;
1386 case 114: return gdb_sys_wait4
;
1387 case 115: return gdb_sys_swapoff
;
1388 case 116: return gdb_sys_sysinfo
;
1389 case 117: return gdb_sys_ipc
;
1390 case 118: return gdb_sys_fsync
;
1391 case 119: return gdb_sys_sigreturn
;
1392 case 120: return gdb_sys_clone
;
1393 case 121: return gdb_sys_setdomainname
;
1394 case 122: return gdb_sys_uname
;
1395 case 124: return gdb_sys_adjtimex
;
1396 case 125: return gdb_sys_mprotect
;
1397 case 126: return gdb_sys_sigprocmask
;
1398 case 128: return gdb_sys_init_module
;
1399 case 129: return gdb_sys_delete_module
;
1400 case 131: return gdb_sys_quotactl
;
1401 case 132: return gdb_sys_getpgid
;
1402 case 133: return gdb_sys_fchdir
;
1403 case 134: return gdb_sys_bdflush
;
1404 case 135: return gdb_sys_sysfs
;
1405 case 136: return gdb_sys_personality
;
1406 case 138: return gdb_sys_setfsuid16
;
1407 case 139: return gdb_sys_setfsgid16
;
1408 case 140: return gdb_sys_llseek
;
1409 case 141: return gdb_sys_getdents
;
1410 case 142: return gdb_sys_select
;
1411 case 143: return gdb_sys_flock
;
1412 case 144: return gdb_sys_msync
;
1413 case 145: return gdb_sys_readv
;
1414 case 146: return gdb_sys_writev
;
1415 case 147: return gdb_sys_getsid
;
1416 case 148: return gdb_sys_fdatasync
;
1417 case 149: return gdb_sys_sysctl
;
1418 case 150: return gdb_sys_mlock
;
1419 case 151: return gdb_sys_munlock
;
1420 case 152: return gdb_sys_mlockall
;
1421 case 153: return gdb_sys_munlockall
;
1422 case 154: return gdb_sys_sched_setparam
;
1423 case 155: return gdb_sys_sched_getparam
;
1424 case 156: return gdb_sys_sched_setscheduler
;
1425 case 157: return gdb_sys_sched_getscheduler
;
1426 case 158: return gdb_sys_sched_yield
;
1427 case 159: return gdb_sys_sched_get_priority_max
;
1428 case 160: return gdb_sys_sched_get_priority_min
;
1429 case 161: return gdb_sys_sched_rr_get_interval
;
1430 case 162: return gdb_sys_nanosleep
;
1431 case 163: return gdb_sys_mremap
;
1432 case 164: return gdb_sys_setresuid16
;
1433 case 165: return gdb_sys_getresuid16
;
1434 case 168: return gdb_sys_poll
;
1435 case 169: return gdb_sys_nfsservctl
;
1436 case 170: return gdb_sys_setresgid
;
1437 case 171: return gdb_sys_getresgid
;
1438 case 172: return gdb_sys_prctl
;
1439 case 173: return gdb_sys_rt_sigreturn
;
1440 case 174: return gdb_sys_rt_sigaction
;
1441 case 175: return gdb_sys_rt_sigprocmask
;
1442 case 176: return gdb_sys_rt_sigpending
;
1443 case 177: return gdb_sys_rt_sigtimedwait
;
1444 case 178: return gdb_sys_rt_sigqueueinfo
;
1445 case 179: return gdb_sys_rt_sigsuspend
;
1446 case 180: return gdb_sys_pread64
;
1447 case 181: return gdb_sys_pwrite64
;
1448 case 182: return gdb_sys_chown
;
1449 case 183: return gdb_sys_getcwd
;
1450 case 184: return gdb_sys_capget
;
1451 case 185: return gdb_sys_capset
;
1452 case 186: return gdb_sys_sigaltstack
;
1453 case 187: return gdb_sys_sendfile
;
1454 case 190: return gdb_sys_vfork
;
1455 case 191: return gdb_sys_getrlimit
;
1456 case 192: return gdb_sys_mmap2
;
1457 case 193: return gdb_sys_truncate64
;
1458 case 194: return gdb_sys_ftruncate64
;
1459 case 195: return gdb_sys_stat64
;
1460 case 196: return gdb_sys_lstat64
;
1461 case 197: return gdb_sys_fstat64
;
1462 case 198: return gdb_sys_lchown
;
1463 case 199: return gdb_sys_getuid
;
1464 case 200: return gdb_sys_getgid
;
1465 case 201: return gdb_sys_geteuid
;
1466 case 202: return gdb_sys_getegid
;
1467 case 203: return gdb_sys_setreuid
;
1468 case 204: return gdb_sys_setregid
;
1469 case 205: return gdb_sys_getgroups
;
1470 case 206: return gdb_sys_setgroups
;
1471 case 207: return gdb_sys_fchown
;
1472 case 208: return gdb_sys_setresuid
;
1473 case 209: return gdb_sys_getresuid
;
1474 case 210: return gdb_sys_setresgid
;
1475 case 211: return gdb_sys_getresgid
;
1476 case 212: return gdb_sys_chown
;
1477 case 213: return gdb_sys_setuid
;
1478 case 214: return gdb_sys_setgid
;
1479 case 215: return gdb_sys_setfsuid
;
1480 case 216: return gdb_sys_setfsgid
;
1481 case 217: return gdb_sys_getdents64
;
1482 case 218: return gdb_sys_pivot_root
;
1483 case 219: return gdb_sys_mincore
;
1484 case 220: return gdb_sys_madvise
;
1485 case 221: return gdb_sys_fcntl64
;
1486 case 224: return gdb_sys_gettid
;
1487 case 225: return gdb_sys_readahead
;
1488 case 226: return gdb_sys_setxattr
;
1489 case 227: return gdb_sys_lsetxattr
;
1490 case 228: return gdb_sys_fsetxattr
;
1491 case 229: return gdb_sys_getxattr
;
1492 case 230: return gdb_sys_lgetxattr
;
1493 case 231: return gdb_sys_fgetxattr
;
1494 case 232: return gdb_sys_listxattr
;
1495 case 233: return gdb_sys_llistxattr
;
1496 case 234: return gdb_sys_flistxattr
;
1497 case 235: return gdb_sys_removexattr
;
1498 case 236: return gdb_sys_lremovexattr
;
1499 case 237: return gdb_sys_fremovexattr
;
1500 case 238: return gdb_sys_tkill
;
1501 case 239: return gdb_sys_sendfile64
;
1502 case 240: return gdb_sys_futex
;
1503 case 241: return gdb_sys_sched_setaffinity
;
1504 case 242: return gdb_sys_sched_getaffinity
;
1505 case 243: return gdb_sys_io_setup
;
1506 case 244: return gdb_sys_io_destroy
;
1507 case 245: return gdb_sys_io_getevents
;
1508 case 246: return gdb_sys_io_submit
;
1509 case 247: return gdb_sys_io_cancel
;
1510 case 248: return gdb_sys_exit_group
;
1511 case 249: return gdb_sys_lookup_dcookie
;
1512 case 250: return gdb_sys_epoll_create
;
1513 case 251: return gdb_sys_epoll_ctl
;
1514 case 252: return gdb_sys_epoll_wait
;
1515 case 253: return gdb_sys_remap_file_pages
;
1516 case 256: return gdb_sys_set_tid_address
;
1517 case 257: return gdb_sys_timer_create
;
1518 case 258: return gdb_sys_timer_settime
;
1519 case 259: return gdb_sys_timer_gettime
;
1520 case 260: return gdb_sys_timer_getoverrun
;
1521 case 261: return gdb_sys_timer_delete
;
1522 case 262: return gdb_sys_clock_settime
;
1523 case 263: return gdb_sys_clock_gettime
;
1524 case 264: return gdb_sys_clock_getres
;
1525 case 265: return gdb_sys_clock_nanosleep
;
1526 case 266: return gdb_sys_statfs64
;
1527 case 267: return gdb_sys_fstatfs64
;
1528 case 268: return gdb_sys_tgkill
;
1529 case 269: return gdb_sys_utimes
;
1531 case 270: return gdb_sys_arm_fadvise64_64;
1532 case 271: return gdb_sys_pciconfig_iobase;
1533 case 272: return gdb_sys_pciconfig_read;
1534 case 273: return gdb_sys_pciconfig_write;
1536 case 274: return gdb_sys_mq_open
;
1537 case 275: return gdb_sys_mq_unlink
;
1538 case 276: return gdb_sys_mq_timedsend
;
1539 case 277: return gdb_sys_mq_timedreceive
;
1540 case 278: return gdb_sys_mq_notify
;
1541 case 279: return gdb_sys_mq_getsetattr
;
1542 case 280: return gdb_sys_waitid
;
1543 case 281: return gdb_sys_socket
;
1544 case 282: return gdb_sys_bind
;
1545 case 283: return gdb_sys_connect
;
1546 case 284: return gdb_sys_listen
;
1547 case 285: return gdb_sys_accept
;
1548 case 286: return gdb_sys_getsockname
;
1549 case 287: return gdb_sys_getpeername
;
1550 case 288: return gdb_sys_socketpair
;
1551 case 289: /* send */ return gdb_sys_no_syscall
;
1552 case 290: return gdb_sys_sendto
;
1553 case 291: return gdb_sys_recv
;
1554 case 292: return gdb_sys_recvfrom
;
1555 case 293: return gdb_sys_shutdown
;
1556 case 294: return gdb_sys_setsockopt
;
1557 case 295: return gdb_sys_getsockopt
;
1558 case 296: return gdb_sys_sendmsg
;
1559 case 297: return gdb_sys_recvmsg
;
1560 case 298: return gdb_sys_semop
;
1561 case 299: return gdb_sys_semget
;
1562 case 300: return gdb_sys_semctl
;
1563 case 301: return gdb_sys_msgsnd
;
1564 case 302: return gdb_sys_msgrcv
;
1565 case 303: return gdb_sys_msgget
;
1566 case 304: return gdb_sys_msgctl
;
1567 case 305: return gdb_sys_shmat
;
1568 case 306: return gdb_sys_shmdt
;
1569 case 307: return gdb_sys_shmget
;
1570 case 308: return gdb_sys_shmctl
;
1571 case 309: return gdb_sys_add_key
;
1572 case 310: return gdb_sys_request_key
;
1573 case 311: return gdb_sys_keyctl
;
1574 case 312: return gdb_sys_semtimedop
;
1575 case 313: /* vserver */ return gdb_sys_no_syscall
;
1576 case 314: return gdb_sys_ioprio_set
;
1577 case 315: return gdb_sys_ioprio_get
;
1578 case 316: return gdb_sys_inotify_init
;
1579 case 317: return gdb_sys_inotify_add_watch
;
1580 case 318: return gdb_sys_inotify_rm_watch
;
1581 case 319: return gdb_sys_mbind
;
1582 case 320: return gdb_sys_get_mempolicy
;
1583 case 321: return gdb_sys_set_mempolicy
;
1584 case 322: return gdb_sys_openat
;
1585 case 323: return gdb_sys_mkdirat
;
1586 case 324: return gdb_sys_mknodat
;
1587 case 325: return gdb_sys_fchownat
;
1588 case 326: return gdb_sys_futimesat
;
1589 case 327: return gdb_sys_fstatat64
;
1590 case 328: return gdb_sys_unlinkat
;
1591 case 329: return gdb_sys_renameat
;
1592 case 330: return gdb_sys_linkat
;
1593 case 331: return gdb_sys_symlinkat
;
1594 case 332: return gdb_sys_readlinkat
;
1595 case 333: return gdb_sys_fchmodat
;
1596 case 334: return gdb_sys_faccessat
;
1597 case 335: return gdb_sys_pselect6
;
1598 case 336: return gdb_sys_ppoll
;
1599 case 337: return gdb_sys_unshare
;
1600 case 338: return gdb_sys_set_robust_list
;
1601 case 339: return gdb_sys_get_robust_list
;
1602 case 340: return gdb_sys_splice
;
1603 /*case 341: return gdb_sys_arm_sync_file_range;*/
1604 case 342: return gdb_sys_tee
;
1605 case 343: return gdb_sys_vmsplice
;
1606 case 344: return gdb_sys_move_pages
;
1607 case 345: return gdb_sys_getcpu
;
1608 case 346: return gdb_sys_epoll_pwait
;
1609 case 347: return gdb_sys_kexec_load
;
1611 case 348: return gdb_sys_utimensat;
1612 case 349: return gdb_sys_signalfd;
1613 case 350: return gdb_sys_timerfd_create;
1614 case 351: return gdb_sys_eventfd;
1616 case 352: return gdb_sys_fallocate
;
1618 case 353: return gdb_sys_timerfd_settime;
1619 case 354: return gdb_sys_timerfd_gettime;
1620 case 355: return gdb_sys_signalfd4;
1622 case 356: return gdb_sys_eventfd2
;
1623 case 357: return gdb_sys_epoll_create1
;
1624 case 358: return gdb_sys_dup3
;
1625 case 359: return gdb_sys_pipe2
;
1626 case 360: return gdb_sys_inotify_init1
;
1628 case 361: return gdb_sys_preadv;
1629 case 362: return gdb_sys_pwritev;
1630 case 363: return gdb_sys_rt_tgsigqueueinfo;
1631 case 364: return gdb_sys_perf_event_open;
1632 case 365: return gdb_sys_recvmmsg;
1633 case 366: return gdb_sys_accept4;
1634 case 367: return gdb_sys_fanotify_init;
1635 case 368: return gdb_sys_fanotify_mark;
1636 case 369: return gdb_sys_prlimit64;
1637 case 370: return gdb_sys_name_to_handle_at;
1638 case 371: return gdb_sys_open_by_handle_at;
1639 case 372: return gdb_sys_clock_adjtime;
1640 case 373: return gdb_sys_syncfs;
1641 case 374: return gdb_sys_sendmmsg;
1642 case 375: return gdb_sys_setns;
1643 case 376: return gdb_sys_process_vm_readv;
1644 case 377: return gdb_sys_process_vm_writev;
1645 case 378: return gdb_sys_kcmp;
1646 case 379: return gdb_sys_finit_module;
1648 case 983041: /* ARM_breakpoint */ return gdb_sys_no_syscall
;
1649 case 983042: /* ARM_cacheflush */ return gdb_sys_no_syscall
;
1650 case 983043: /* ARM_usr26 */ return gdb_sys_no_syscall
;
1651 case 983044: /* ARM_usr32 */ return gdb_sys_no_syscall
;
1652 case 983045: /* ARM_set_tls */ return gdb_sys_no_syscall
;
1653 default: return gdb_sys_no_syscall
;
1657 /* Record all registers but PC register for process-record. */
1660 arm_all_but_pc_registers_record (struct regcache
*regcache
)
1664 for (i
= 0; i
< ARM_PC_REGNUM
; i
++)
1666 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
+ i
))
1670 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1676 /* Handler for arm system call instruction recording. */
1679 arm_linux_syscall_record (struct regcache
*regcache
, unsigned long svc_number
)
1682 enum gdb_syscall syscall_gdb
;
1684 syscall_gdb
= arm_canonicalize_syscall (svc_number
);
1686 if (syscall_gdb
== gdb_sys_no_syscall
)
1688 printf_unfiltered (_("Process record and replay target doesn't "
1689 "support syscall number %s\n"),
1690 plongest (svc_number
));
1694 if (syscall_gdb
== gdb_sys_sigreturn
1695 || syscall_gdb
== gdb_sys_rt_sigreturn
)
1697 if (arm_all_but_pc_registers_record (regcache
))
1702 ret
= record_linux_system_call (syscall_gdb
, regcache
,
1703 &arm_linux_record_tdep
);
1707 /* Record the return value of the system call. */
1708 if (record_full_arch_list_add_reg (regcache
, ARM_A1_REGNUM
))
1711 if (record_full_arch_list_add_reg (regcache
, ARM_LR_REGNUM
))
1714 if (record_full_arch_list_add_reg (regcache
, ARM_PS_REGNUM
))
1720 /* Implement the skip_trampoline_code gdbarch method. */
1723 arm_linux_skip_trampoline_code (struct frame_info
*frame
, CORE_ADDR pc
)
1725 CORE_ADDR target_pc
= arm_skip_stub (frame
, pc
);
1730 return find_solib_trampoline_target (frame
, pc
);
1734 arm_linux_init_abi (struct gdbarch_info info
,
1735 struct gdbarch
*gdbarch
)
1737 static const char *const stap_integer_prefixes
[] = { "#", "$", "", NULL
};
1738 static const char *const stap_register_prefixes
[] = { "r", NULL
};
1739 static const char *const stap_register_indirection_prefixes
[] = { "[",
1741 static const char *const stap_register_indirection_suffixes
[] = { "]",
1743 struct gdbarch_tdep
*tdep
= gdbarch_tdep (gdbarch
);
1745 linux_init_abi (info
, gdbarch
);
1747 tdep
->lowest_pc
= 0x8000;
1748 if (info
.byte_order_for_code
== BFD_ENDIAN_BIG
)
1750 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1751 tdep
->arm_breakpoint
= eabi_linux_arm_be_breakpoint
;
1753 tdep
->arm_breakpoint
= arm_linux_arm_be_breakpoint
;
1754 tdep
->thumb_breakpoint
= arm_linux_thumb_be_breakpoint
;
1755 tdep
->thumb2_breakpoint
= arm_linux_thumb2_be_breakpoint
;
1759 if (tdep
->arm_abi
== ARM_ABI_AAPCS
)
1760 tdep
->arm_breakpoint
= eabi_linux_arm_le_breakpoint
;
1762 tdep
->arm_breakpoint
= arm_linux_arm_le_breakpoint
;
1763 tdep
->thumb_breakpoint
= arm_linux_thumb_le_breakpoint
;
1764 tdep
->thumb2_breakpoint
= arm_linux_thumb2_le_breakpoint
;
1766 tdep
->arm_breakpoint_size
= sizeof (arm_linux_arm_le_breakpoint
);
1767 tdep
->thumb_breakpoint_size
= sizeof (arm_linux_thumb_le_breakpoint
);
1768 tdep
->thumb2_breakpoint_size
= sizeof (arm_linux_thumb2_le_breakpoint
);
1770 if (tdep
->fp_model
== ARM_FLOAT_AUTO
)
1771 tdep
->fp_model
= ARM_FLOAT_FPA
;
1773 switch (tdep
->fp_model
)
1776 tdep
->jb_pc
= ARM_LINUX_JB_PC_FPA
;
1778 case ARM_FLOAT_SOFT_FPA
:
1779 case ARM_FLOAT_SOFT_VFP
:
1781 tdep
->jb_pc
= ARM_LINUX_JB_PC_EABI
;
1785 (__FILE__
, __LINE__
,
1786 _("arm_linux_init_abi: Floating point model not supported"));
1789 tdep
->jb_elt_size
= ARM_LINUX_JB_ELEMENT_SIZE
;
1791 set_solib_svr4_fetch_link_map_offsets
1792 (gdbarch
, svr4_ilp32_fetch_link_map_offsets
);
1794 /* Single stepping. */
1795 set_gdbarch_software_single_step (gdbarch
, arm_linux_software_single_step
);
1797 /* Shared library handling. */
1798 set_gdbarch_skip_trampoline_code (gdbarch
, arm_linux_skip_trampoline_code
);
1799 set_gdbarch_skip_solib_resolver (gdbarch
, glibc_skip_solib_resolver
);
1801 /* Enable TLS support. */
1802 set_gdbarch_fetch_tls_load_module_address (gdbarch
,
1803 svr4_fetch_objfile_link_map
);
1805 tramp_frame_prepend_unwinder (gdbarch
,
1806 &arm_linux_sigreturn_tramp_frame
);
1807 tramp_frame_prepend_unwinder (gdbarch
,
1808 &arm_linux_rt_sigreturn_tramp_frame
);
1809 tramp_frame_prepend_unwinder (gdbarch
,
1810 &arm_eabi_linux_sigreturn_tramp_frame
);
1811 tramp_frame_prepend_unwinder (gdbarch
,
1812 &arm_eabi_linux_rt_sigreturn_tramp_frame
);
1813 tramp_frame_prepend_unwinder (gdbarch
,
1814 &thumb2_eabi_linux_sigreturn_tramp_frame
);
1815 tramp_frame_prepend_unwinder (gdbarch
,
1816 &thumb2_eabi_linux_rt_sigreturn_tramp_frame
);
1817 tramp_frame_prepend_unwinder (gdbarch
,
1818 &arm_linux_restart_syscall_tramp_frame
);
1819 tramp_frame_prepend_unwinder (gdbarch
,
1820 &arm_kernel_linux_restart_syscall_tramp_frame
);
1822 /* Core file support. */
1823 set_gdbarch_iterate_over_regset_sections
1824 (gdbarch
, arm_linux_iterate_over_regset_sections
);
1825 set_gdbarch_core_read_description (gdbarch
, arm_linux_core_read_description
);
1827 /* Displaced stepping. */
1828 set_gdbarch_displaced_step_copy_insn (gdbarch
,
1829 arm_linux_displaced_step_copy_insn
);
1830 set_gdbarch_displaced_step_fixup (gdbarch
, arm_displaced_step_fixup
);
1831 set_gdbarch_displaced_step_free_closure (gdbarch
,
1832 simple_displaced_step_free_closure
);
1833 set_gdbarch_displaced_step_location (gdbarch
, linux_displaced_step_location
);
1835 /* Reversible debugging, process record. */
1836 set_gdbarch_process_record (gdbarch
, arm_process_record
);
1838 /* SystemTap functions. */
1839 set_gdbarch_stap_integer_prefixes (gdbarch
, stap_integer_prefixes
);
1840 set_gdbarch_stap_register_prefixes (gdbarch
, stap_register_prefixes
);
1841 set_gdbarch_stap_register_indirection_prefixes (gdbarch
,
1842 stap_register_indirection_prefixes
);
1843 set_gdbarch_stap_register_indirection_suffixes (gdbarch
,
1844 stap_register_indirection_suffixes
);
1845 set_gdbarch_stap_gdb_register_prefix (gdbarch
, "r");
1846 set_gdbarch_stap_is_single_operand (gdbarch
, arm_stap_is_single_operand
);
1847 set_gdbarch_stap_parse_special_token (gdbarch
,
1848 arm_stap_parse_special_token
);
1850 /* `catch syscall' */
1851 set_xml_syscall_file_name (gdbarch
, "syscalls/arm-linux.xml");
1852 set_gdbarch_get_syscall_number (gdbarch
, arm_linux_get_syscall_number
);
1854 /* Syscall record. */
1855 tdep
->arm_syscall_record
= arm_linux_syscall_record
;
1857 /* Initialize the arm_linux_record_tdep. */
1858 /* These values are the size of the type that will be used in a system
1859 call. They are obtained from Linux Kernel source. */
1860 arm_linux_record_tdep
.size_pointer
1861 = gdbarch_ptr_bit (gdbarch
) / TARGET_CHAR_BIT
;
1862 arm_linux_record_tdep
.size__old_kernel_stat
= 32;
1863 arm_linux_record_tdep
.size_tms
= 16;
1864 arm_linux_record_tdep
.size_loff_t
= 8;
1865 arm_linux_record_tdep
.size_flock
= 16;
1866 arm_linux_record_tdep
.size_oldold_utsname
= 45;
1867 arm_linux_record_tdep
.size_ustat
= 20;
1868 arm_linux_record_tdep
.size_old_sigaction
= 16;
1869 arm_linux_record_tdep
.size_old_sigset_t
= 4;
1870 arm_linux_record_tdep
.size_rlimit
= 8;
1871 arm_linux_record_tdep
.size_rusage
= 72;
1872 arm_linux_record_tdep
.size_timeval
= 8;
1873 arm_linux_record_tdep
.size_timezone
= 8;
1874 arm_linux_record_tdep
.size_old_gid_t
= 2;
1875 arm_linux_record_tdep
.size_old_uid_t
= 2;
1876 arm_linux_record_tdep
.size_fd_set
= 128;
1877 arm_linux_record_tdep
.size_old_dirent
= 268;
1878 arm_linux_record_tdep
.size_statfs
= 64;
1879 arm_linux_record_tdep
.size_statfs64
= 84;
1880 arm_linux_record_tdep
.size_sockaddr
= 16;
1881 arm_linux_record_tdep
.size_int
1882 = gdbarch_int_bit (gdbarch
) / TARGET_CHAR_BIT
;
1883 arm_linux_record_tdep
.size_long
1884 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1885 arm_linux_record_tdep
.size_ulong
1886 = gdbarch_long_bit (gdbarch
) / TARGET_CHAR_BIT
;
1887 arm_linux_record_tdep
.size_msghdr
= 28;
1888 arm_linux_record_tdep
.size_itimerval
= 16;
1889 arm_linux_record_tdep
.size_stat
= 88;
1890 arm_linux_record_tdep
.size_old_utsname
= 325;
1891 arm_linux_record_tdep
.size_sysinfo
= 64;
1892 arm_linux_record_tdep
.size_msqid_ds
= 88;
1893 arm_linux_record_tdep
.size_shmid_ds
= 84;
1894 arm_linux_record_tdep
.size_new_utsname
= 390;
1895 arm_linux_record_tdep
.size_timex
= 128;
1896 arm_linux_record_tdep
.size_mem_dqinfo
= 24;
1897 arm_linux_record_tdep
.size_if_dqblk
= 68;
1898 arm_linux_record_tdep
.size_fs_quota_stat
= 68;
1899 arm_linux_record_tdep
.size_timespec
= 8;
1900 arm_linux_record_tdep
.size_pollfd
= 8;
1901 arm_linux_record_tdep
.size_NFS_FHSIZE
= 32;
1902 arm_linux_record_tdep
.size_knfsd_fh
= 132;
1903 arm_linux_record_tdep
.size_TASK_COMM_LEN
= 16;
1904 arm_linux_record_tdep
.size_sigaction
= 20;
1905 arm_linux_record_tdep
.size_sigset_t
= 8;
1906 arm_linux_record_tdep
.size_siginfo_t
= 128;
1907 arm_linux_record_tdep
.size_cap_user_data_t
= 12;
1908 arm_linux_record_tdep
.size_stack_t
= 12;
1909 arm_linux_record_tdep
.size_off_t
= arm_linux_record_tdep
.size_long
;
1910 arm_linux_record_tdep
.size_stat64
= 96;
1911 arm_linux_record_tdep
.size_gid_t
= 4;
1912 arm_linux_record_tdep
.size_uid_t
= 4;
1913 arm_linux_record_tdep
.size_PAGE_SIZE
= 4096;
1914 arm_linux_record_tdep
.size_flock64
= 24;
1915 arm_linux_record_tdep
.size_user_desc
= 16;
1916 arm_linux_record_tdep
.size_io_event
= 32;
1917 arm_linux_record_tdep
.size_iocb
= 64;
1918 arm_linux_record_tdep
.size_epoll_event
= 12;
1919 arm_linux_record_tdep
.size_itimerspec
1920 = arm_linux_record_tdep
.size_timespec
* 2;
1921 arm_linux_record_tdep
.size_mq_attr
= 32;
1922 arm_linux_record_tdep
.size_termios
= 36;
1923 arm_linux_record_tdep
.size_termios2
= 44;
1924 arm_linux_record_tdep
.size_pid_t
= 4;
1925 arm_linux_record_tdep
.size_winsize
= 8;
1926 arm_linux_record_tdep
.size_serial_struct
= 60;
1927 arm_linux_record_tdep
.size_serial_icounter_struct
= 80;
1928 arm_linux_record_tdep
.size_hayes_esp_config
= 12;
1929 arm_linux_record_tdep
.size_size_t
= 4;
1930 arm_linux_record_tdep
.size_iovec
= 8;
1931 arm_linux_record_tdep
.size_time_t
= 4;
1933 /* These values are the second argument of system call "sys_ioctl".
1934 They are obtained from Linux Kernel source. */
1935 arm_linux_record_tdep
.ioctl_TCGETS
= 0x5401;
1936 arm_linux_record_tdep
.ioctl_TCSETS
= 0x5402;
1937 arm_linux_record_tdep
.ioctl_TCSETSW
= 0x5403;
1938 arm_linux_record_tdep
.ioctl_TCSETSF
= 0x5404;
1939 arm_linux_record_tdep
.ioctl_TCGETA
= 0x5405;
1940 arm_linux_record_tdep
.ioctl_TCSETA
= 0x5406;
1941 arm_linux_record_tdep
.ioctl_TCSETAW
= 0x5407;
1942 arm_linux_record_tdep
.ioctl_TCSETAF
= 0x5408;
1943 arm_linux_record_tdep
.ioctl_TCSBRK
= 0x5409;
1944 arm_linux_record_tdep
.ioctl_TCXONC
= 0x540a;
1945 arm_linux_record_tdep
.ioctl_TCFLSH
= 0x540b;
1946 arm_linux_record_tdep
.ioctl_TIOCEXCL
= 0x540c;
1947 arm_linux_record_tdep
.ioctl_TIOCNXCL
= 0x540d;
1948 arm_linux_record_tdep
.ioctl_TIOCSCTTY
= 0x540e;
1949 arm_linux_record_tdep
.ioctl_TIOCGPGRP
= 0x540f;
1950 arm_linux_record_tdep
.ioctl_TIOCSPGRP
= 0x5410;
1951 arm_linux_record_tdep
.ioctl_TIOCOUTQ
= 0x5411;
1952 arm_linux_record_tdep
.ioctl_TIOCSTI
= 0x5412;
1953 arm_linux_record_tdep
.ioctl_TIOCGWINSZ
= 0x5413;
1954 arm_linux_record_tdep
.ioctl_TIOCSWINSZ
= 0x5414;
1955 arm_linux_record_tdep
.ioctl_TIOCMGET
= 0x5415;
1956 arm_linux_record_tdep
.ioctl_TIOCMBIS
= 0x5416;
1957 arm_linux_record_tdep
.ioctl_TIOCMBIC
= 0x5417;
1958 arm_linux_record_tdep
.ioctl_TIOCMSET
= 0x5418;
1959 arm_linux_record_tdep
.ioctl_TIOCGSOFTCAR
= 0x5419;
1960 arm_linux_record_tdep
.ioctl_TIOCSSOFTCAR
= 0x541a;
1961 arm_linux_record_tdep
.ioctl_FIONREAD
= 0x541b;
1962 arm_linux_record_tdep
.ioctl_TIOCINQ
= arm_linux_record_tdep
.ioctl_FIONREAD
;
1963 arm_linux_record_tdep
.ioctl_TIOCLINUX
= 0x541c;
1964 arm_linux_record_tdep
.ioctl_TIOCCONS
= 0x541d;
1965 arm_linux_record_tdep
.ioctl_TIOCGSERIAL
= 0x541e;
1966 arm_linux_record_tdep
.ioctl_TIOCSSERIAL
= 0x541f;
1967 arm_linux_record_tdep
.ioctl_TIOCPKT
= 0x5420;
1968 arm_linux_record_tdep
.ioctl_FIONBIO
= 0x5421;
1969 arm_linux_record_tdep
.ioctl_TIOCNOTTY
= 0x5422;
1970 arm_linux_record_tdep
.ioctl_TIOCSETD
= 0x5423;
1971 arm_linux_record_tdep
.ioctl_TIOCGETD
= 0x5424;
1972 arm_linux_record_tdep
.ioctl_TCSBRKP
= 0x5425;
1973 arm_linux_record_tdep
.ioctl_TIOCTTYGSTRUCT
= 0x5426;
1974 arm_linux_record_tdep
.ioctl_TIOCSBRK
= 0x5427;
1975 arm_linux_record_tdep
.ioctl_TIOCCBRK
= 0x5428;
1976 arm_linux_record_tdep
.ioctl_TIOCGSID
= 0x5429;
1977 arm_linux_record_tdep
.ioctl_TCGETS2
= 0x802c542a;
1978 arm_linux_record_tdep
.ioctl_TCSETS2
= 0x402c542b;
1979 arm_linux_record_tdep
.ioctl_TCSETSW2
= 0x402c542c;
1980 arm_linux_record_tdep
.ioctl_TCSETSF2
= 0x402c542d;
1981 arm_linux_record_tdep
.ioctl_TIOCGPTN
= 0x80045430;
1982 arm_linux_record_tdep
.ioctl_TIOCSPTLCK
= 0x40045431;
1983 arm_linux_record_tdep
.ioctl_FIONCLEX
= 0x5450;
1984 arm_linux_record_tdep
.ioctl_FIOCLEX
= 0x5451;
1985 arm_linux_record_tdep
.ioctl_FIOASYNC
= 0x5452;
1986 arm_linux_record_tdep
.ioctl_TIOCSERCONFIG
= 0x5453;
1987 arm_linux_record_tdep
.ioctl_TIOCSERGWILD
= 0x5454;
1988 arm_linux_record_tdep
.ioctl_TIOCSERSWILD
= 0x5455;
1989 arm_linux_record_tdep
.ioctl_TIOCGLCKTRMIOS
= 0x5456;
1990 arm_linux_record_tdep
.ioctl_TIOCSLCKTRMIOS
= 0x5457;
1991 arm_linux_record_tdep
.ioctl_TIOCSERGSTRUCT
= 0x5458;
1992 arm_linux_record_tdep
.ioctl_TIOCSERGETLSR
= 0x5459;
1993 arm_linux_record_tdep
.ioctl_TIOCSERGETMULTI
= 0x545a;
1994 arm_linux_record_tdep
.ioctl_TIOCSERSETMULTI
= 0x545b;
1995 arm_linux_record_tdep
.ioctl_TIOCMIWAIT
= 0x545c;
1996 arm_linux_record_tdep
.ioctl_TIOCGICOUNT
= 0x545d;
1997 arm_linux_record_tdep
.ioctl_TIOCGHAYESESP
= 0x545e;
1998 arm_linux_record_tdep
.ioctl_TIOCSHAYESESP
= 0x545f;
1999 arm_linux_record_tdep
.ioctl_FIOQSIZE
= 0x5460;
2001 /* These values are the second argument of system call "sys_fcntl"
2002 and "sys_fcntl64". They are obtained from Linux Kernel source. */
2003 arm_linux_record_tdep
.fcntl_F_GETLK
= 5;
2004 arm_linux_record_tdep
.fcntl_F_GETLK64
= 12;
2005 arm_linux_record_tdep
.fcntl_F_SETLK64
= 13;
2006 arm_linux_record_tdep
.fcntl_F_SETLKW64
= 14;
2008 arm_linux_record_tdep
.arg1
= ARM_A1_REGNUM
;
2009 arm_linux_record_tdep
.arg2
= ARM_A1_REGNUM
+ 1;
2010 arm_linux_record_tdep
.arg3
= ARM_A1_REGNUM
+ 2;
2011 arm_linux_record_tdep
.arg4
= ARM_A1_REGNUM
+ 3;
2012 arm_linux_record_tdep
.arg5
= ARM_A1_REGNUM
+ 4;
2013 arm_linux_record_tdep
.arg6
= ARM_A1_REGNUM
+ 5;
2014 arm_linux_record_tdep
.arg7
= ARM_A1_REGNUM
+ 6;
2017 /* Provide a prototype to silence -Wmissing-prototypes. */
2018 extern initialize_file_ftype _initialize_arm_linux_tdep
;
2021 _initialize_arm_linux_tdep (void)
2023 gdbarch_register_osabi (bfd_arch_arm
, 0, GDB_OSABI_LINUX
,
2024 arm_linux_init_abi
);