GDB (xrefs)

/tmp/gdb-8.1/gdb/arm-linux-tdep.c
Go to the documentation of this file.
1 /* GNU/Linux on ARM target support.
2
3 Copyright (C) 1999-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "target.h"
22 #include "value.h"
23 #include "gdbtypes.h"
24 #include "gdbcore.h"
25 #include "frame.h"
26 #include "regcache.h"
27 #include "solib-svr4.h"
28 #include "osabi.h"
29 #include "regset.h"
30 #include "trad-frame.h"
31 #include "tramp-frame.h"
32 #include "breakpoint.h"
33 #include "auxv.h"
34 #include "xml-syscall.h"
35
36 #include "arch/arm.h"
37 #include "arch/arm-get-next-pcs.h"
38 #include "arch/arm-linux.h"
39 #include "arm-tdep.h"
40 #include "arm-linux-tdep.h"
41 #include "linux-tdep.h"
42 #include "glibc-tdep.h"
43 #include "arch-utils.h"
44 #include "inferior.h"
45 #include "infrun.h"
46 #include "gdbthread.h"
47 #include "symfile.h"
48
49 #include "record-full.h"
50 #include "linux-record.h"
51
52 #include "cli/cli-utils.h"
53 #include "stap-probe.h"
54 #include "parser-defs.h"
55 #include "user-regs.h"
56 #include <ctype.h>
57 #include "elf/common.h"
58 extern int arm_apcs_32;
59
60 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
61 is to execute a particular software interrupt, rather than use a
62 particular undefined instruction to provoke a trap. Upon exection
63 of the software interrupt the kernel stops the inferior with a
64 SIGTRAP, and wakes the debugger. */
65
66 static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
67
68 static const gdb_byte arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
69
70 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
71 the operand of the swi if old-ABI compatibility is disabled. Therefore,
72 use an undefined instruction instead. This is supported as of kernel
73 version 2.5.70 (May 2003), so should be a safe assumption for EABI
74 binaries. */
75
76 static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
77
78 static const gdb_byte eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
79
80 /* All the kernels which support Thumb support using a specific undefined
81 instruction for the Thumb breakpoint. */
82
83 static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
84
85 static const gdb_byte arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
86
87 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
88 we must use a length-appropriate breakpoint for 32-bit Thumb
89 instructions. See also thumb_get_next_pc. */
90
91 static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };
92
93 static const gdb_byte arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 };
94
95 /* Description of the longjmp buffer. The buffer is treated as an array of
96 elements of size ARM_LINUX_JB_ELEMENT_SIZE.
97
98 The location of saved registers in this buffer (in particular the PC
99 to use after longjmp is called) varies depending on the ABI (in
100 particular the FP model) and also (possibly) the C Library.
101
102 For glibc, eglibc, and uclibc the following holds: If the FP model is
103 SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
104 buffer. This is also true for the SoftFPA model. However, for the FPA
105 model the PC is at offset 21 in the buffer. */
106 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
107 #define ARM_LINUX_JB_PC_FPA 21
108 #define ARM_LINUX_JB_PC_EABI 9
109
110 /*
111 Dynamic Linking on ARM GNU/Linux
112 --------------------------------
113
114 Note: PLT = procedure linkage table
115 GOT = global offset table
116
117 As much as possible, ELF dynamic linking defers the resolution of
118 jump/call addresses until the last minute. The technique used is
119 inspired by the i386 ELF design, and is based on the following
120 constraints.
121
122 1) The calling technique should not force a change in the assembly
123 code produced for apps; it MAY cause changes in the way assembly
124 code is produced for position independent code (i.e. shared
125 libraries).
126
127 2) The technique must be such that all executable areas must not be
128 modified; and any modified areas must not be executed.
129
130 To do this, there are three steps involved in a typical jump:
131
132 1) in the code
133 2) through the PLT
134 3) using a pointer from the GOT
135
136 When the executable or library is first loaded, each GOT entry is
137 initialized to point to the code which implements dynamic name
138 resolution and code finding. This is normally a function in the
139 program interpreter (on ARM GNU/Linux this is usually
140 ld-linux.so.2, but it does not have to be). On the first
141 invocation, the function is located and the GOT entry is replaced
142 with the real function address. Subsequent calls go through steps
143 1, 2 and 3 and end up calling the real code.
144
145 1) In the code:
146
147 b function_call
148 bl function_call
149
150 This is typical ARM code using the 26 bit relative branch or branch
151 and link instructions. The target of the instruction
152 (function_call is usually the address of the function to be called.
153 In position independent code, the target of the instruction is
154 actually an entry in the PLT when calling functions in a shared
155 library. Note that this call is identical to a normal function
156 call, only the target differs.
157
158 2) In the PLT:
159
160 The PLT is a synthetic area, created by the linker. It exists in
161 both executables and libraries. It is an array of stubs, one per
162 imported function call. It looks like this:
163
164 PLT[0]:
165 str lr, [sp, #-4]! @push the return address (lr)
166 ldr lr, [pc, #16] @load from 6 words ahead
167 add lr, pc, lr @form an address for GOT[0]
168 ldr pc, [lr, #8]! @jump to the contents of that addr
169
170 The return address (lr) is pushed on the stack and used for
171 calculations. The load on the second line loads the lr with
172 &GOT[3] - . - 20. The addition on the third leaves:
173
174 lr = (&GOT[3] - . - 20) + (. + 8)
175 lr = (&GOT[3] - 12)
176 lr = &GOT[0]
177
178 On the fourth line, the pc and lr are both updated, so that:
179
180 pc = GOT[2]
181 lr = &GOT[0] + 8
182 = &GOT[2]
183
184 NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
185 "tight", but allows us to keep all the PLT entries the same size.
186
187 PLT[n+1]:
188 ldr ip, [pc, #4] @load offset from gotoff
189 add ip, pc, ip @add the offset to the pc
190 ldr pc, [ip] @jump to that address
191 gotoff: .word GOT[n+3] - .
192
193 The load on the first line, gets an offset from the fourth word of
194 the PLT entry. The add on the second line makes ip = &GOT[n+3],
195 which contains either a pointer to PLT[0] (the fixup trampoline) or
196 a pointer to the actual code.
197
198 3) In the GOT:
199
200 The GOT contains helper pointers for both code (PLT) fixups and
201 data fixups. The first 3 entries of the GOT are special. The next
202 M entries (where M is the number of entries in the PLT) belong to
203 the PLT fixups. The next D (all remaining) entries belong to
204 various data fixups. The actual size of the GOT is 3 + M + D.
205
206 The GOT is also a synthetic area, created by the linker. It exists
207 in both executables and libraries. When the GOT is first
208 initialized , all the GOT entries relating to PLT fixups are
209 pointing to code back at PLT[0].
210
211 The special entries in the GOT are:
212
213 GOT[0] = linked list pointer used by the dynamic loader
214 GOT[1] = pointer to the reloc table for this module
215 GOT[2] = pointer to the fixup/resolver code
216
217 The first invocation of function call comes through and uses the
218 fixup/resolver code. On the entry to the fixup/resolver code:
219
220 ip = &GOT[n+3]
221 lr = &GOT[2]
222 stack[0] = return address (lr) of the function call
223 [r0, r1, r2, r3] are still the arguments to the function call
224
225 This is enough information for the fixup/resolver code to work
226 with. Before the fixup/resolver code returns, it actually calls
227 the requested function and repairs &GOT[n+3]. */
228
229 /* The constants below were determined by examining the following files
230 in the linux kernel sources:
231
232 arch/arm/kernel/signal.c
233 - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
234 include/asm-arm/unistd.h
235 - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
236
237 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
238 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
239
240 /* For ARM EABI, the syscall number is not in the SWI instruction
241 (instead it is loaded into r7). We recognize the pattern that
242 glibc uses... alternatively, we could arrange to do this by
243 function name, but they are not always exported. */
244 #define ARM_SET_R7_SIGRETURN 0xe3a07077
245 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
246 #define ARM_EABI_SYSCALL 0xef000000
247
248 /* Equivalent patterns for Thumb2. */
249 #define THUMB2_SET_R7_SIGRETURN1 0xf04f
250 #define THUMB2_SET_R7_SIGRETURN2 0x0777
251 #define THUMB2_SET_R7_RT_SIGRETURN1 0xf04f
252 #define THUMB2_SET_R7_RT_SIGRETURN2 0x07ad
253 #define THUMB2_EABI_SYSCALL 0xdf00
254
255 /* OABI syscall restart trampoline, used for EABI executables too
256 whenever OABI support has been enabled in the kernel. */
257 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
258 #define ARM_LDR_PC_SP_12 0xe49df00c
259 #define ARM_LDR_PC_SP_4 0xe49df004
260
261 /* Syscall number for sigreturn. */
262 #define ARM_SIGRETURN 119
263 /* Syscall number for rt_sigreturn. */
264 #define ARM_RT_SIGRETURN 173
265
266 static CORE_ADDR
267 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self);
268
269 /* Operation function pointers for get_next_pcs. */
270 static struct arm_get_next_pcs_ops arm_linux_get_next_pcs_ops = {
271 arm_get_next_pcs_read_memory_unsigned_integer,
272 arm_linux_get_next_pcs_syscall_next_pc,
273 arm_get_next_pcs_addr_bits_remove,
274 arm_get_next_pcs_is_thumb,
275 arm_linux_get_next_pcs_fixup,
276 };
277
278 static void
279 arm_linux_sigtramp_cache (struct frame_info *this_frame,
280 struct trad_frame_cache *this_cache,
281 CORE_ADDR func, int regs_offset)
282 {
283 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
284 CORE_ADDR base = sp + regs_offset;
285 int i;
286
287 for (i = 0; i < 16; i++)
288 trad_frame_set_reg_addr (this_cache, i, base + i * 4);
289
290 trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
291
292 /* The VFP or iWMMXt registers may be saved on the stack, but there's
293 no reliable way to restore them (yet). */
294
295 /* Save a frame ID. */
296 trad_frame_set_id (this_cache, frame_id_build (sp, func));
297 }
298
299 /* See arm-linux.h for stack layout details. */
300 static void
301 arm_linux_sigreturn_init (const struct tramp_frame *self,
302 struct frame_info *this_frame,
303 struct trad_frame_cache *this_cache,
304 CORE_ADDR func)
305 {
306 struct gdbarch *gdbarch = get_frame_arch (this_frame);
307 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
308 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
309 ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
310
311 if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
312 arm_linux_sigtramp_cache (this_frame, this_cache, func,
313 ARM_UCONTEXT_SIGCONTEXT
314 + ARM_SIGCONTEXT_R0);
315 else
316 arm_linux_sigtramp_cache (this_frame, this_cache, func,
317 ARM_SIGCONTEXT_R0);
318 }
319
320 static void
321 arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
322 struct frame_info *this_frame,
323 struct trad_frame_cache *this_cache,
324 CORE_ADDR func)
325 {
326 struct gdbarch *gdbarch = get_frame_arch (this_frame);
327 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
328 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
329 ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
330
331 if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
332 arm_linux_sigtramp_cache (this_frame, this_cache, func,
333 ARM_OLD_RT_SIGFRAME_UCONTEXT
334 + ARM_UCONTEXT_SIGCONTEXT
335 + ARM_SIGCONTEXT_R0);
336 else
337 arm_linux_sigtramp_cache (this_frame, this_cache, func,
338 ARM_NEW_RT_SIGFRAME_UCONTEXT
339 + ARM_UCONTEXT_SIGCONTEXT
340 + ARM_SIGCONTEXT_R0);
341 }
342
343 static void
344 arm_linux_restart_syscall_init (const struct tramp_frame *self,
345 struct frame_info *this_frame,
346 struct trad_frame_cache *this_cache,
347 CORE_ADDR func)
348 {
349 struct gdbarch *gdbarch = get_frame_arch (this_frame);
350 CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
351 CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4);
352 CORE_ADDR cpsr = get_frame_register_unsigned (this_frame, ARM_PS_REGNUM);
353 ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
354 int sp_offset;
355
356 /* There are two variants of this trampoline; with older kernels, the
357 stub is placed on the stack, while newer kernels use the stub from
358 the vector page. They are identical except that the older version
359 increments SP by 12 (to skip stored PC and the stub itself), while
360 the newer version increments SP only by 4 (just the stored PC). */
361 if (self->insn[1].bytes == ARM_LDR_PC_SP_4)
362 sp_offset = 4;
363 else
364 sp_offset = 12;
365
366 /* Update Thumb bit in CPSR. */
367 if (pc & 1)
368 cpsr |= t_bit;
369 else
370 cpsr &= ~t_bit;
371
372 /* Remove Thumb bit from PC. */
373 pc = gdbarch_addr_bits_remove (gdbarch, pc);
374
375 /* Save previous register values. */
376 trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset);
377 trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc);
378 trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr);
379
380 /* Save a frame ID. */
381 trad_frame_set_id (this_cache, frame_id_build (sp, func));
382 }
383
384 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
385 SIGTRAMP_FRAME,
386 4,
387 {
388 { ARM_LINUX_SIGRETURN_INSTR, -1 },
389 { TRAMP_SENTINEL_INSN }
390 },
391 arm_linux_sigreturn_init
392 };
393
394 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
395 SIGTRAMP_FRAME,
396 4,
397 {
398 { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
399 { TRAMP_SENTINEL_INSN }
400 },
401 arm_linux_rt_sigreturn_init
402 };
403
404 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
405 SIGTRAMP_FRAME,
406 4,
407 {
408 { ARM_SET_R7_SIGRETURN, -1 },
409 { ARM_EABI_SYSCALL, -1 },
410 { TRAMP_SENTINEL_INSN }
411 },
412 arm_linux_sigreturn_init
413 };
414
415 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
416 SIGTRAMP_FRAME,
417 4,
418 {
419 { ARM_SET_R7_RT_SIGRETURN, -1 },
420 { ARM_EABI_SYSCALL, -1 },
421 { TRAMP_SENTINEL_INSN }
422 },
423 arm_linux_rt_sigreturn_init
424 };
425
426 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = {
427 SIGTRAMP_FRAME,
428 2,
429 {
430 { THUMB2_SET_R7_SIGRETURN1, -1 },
431 { THUMB2_SET_R7_SIGRETURN2, -1 },
432 { THUMB2_EABI_SYSCALL, -1 },
433 { TRAMP_SENTINEL_INSN }
434 },
435 arm_linux_sigreturn_init
436 };
437
438 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = {
439 SIGTRAMP_FRAME,
440 2,
441 {
442 { THUMB2_SET_R7_RT_SIGRETURN1, -1 },
443 { THUMB2_SET_R7_RT_SIGRETURN2, -1 },
444 { THUMB2_EABI_SYSCALL, -1 },
445 { TRAMP_SENTINEL_INSN }
446 },
447 arm_linux_rt_sigreturn_init
448 };
449
450 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
451 NORMAL_FRAME,
452 4,
453 {
454 { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
455 { ARM_LDR_PC_SP_12, -1 },
456 { TRAMP_SENTINEL_INSN }
457 },
458 arm_linux_restart_syscall_init
459 };
460
461 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
462 NORMAL_FRAME,
463 4,
464 {
465 { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
466 { ARM_LDR_PC_SP_4, -1 },
467 { TRAMP_SENTINEL_INSN }
468 },
469 arm_linux_restart_syscall_init
470 };
471
472 /* Core file and register set support. */
473
474 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
475
476 void
477 arm_linux_supply_gregset (const struct regset *regset,
478 struct regcache *regcache,
479 int regnum, const void *gregs_buf, size_t len)
480 {
481 struct gdbarch *gdbarch = regcache->arch ();
482 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
483 const gdb_byte *gregs = (const gdb_byte *) gregs_buf;
484 int regno;
485 CORE_ADDR reg_pc;
486 gdb_byte pc_buf[INT_REGISTER_SIZE];
487
488 for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
489 if (regnum == -1 || regnum == regno)
490 regcache_raw_supply (regcache, regno,
491 gregs + INT_REGISTER_SIZE * regno);
492
493 if (regnum == ARM_PS_REGNUM || regnum == -1)
494 {
495 if (arm_apcs_32)
496 regcache_raw_supply (regcache, ARM_PS_REGNUM,
497 gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
498 else
499 regcache_raw_supply (regcache, ARM_PS_REGNUM,
500 gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
501 }
502
503 if (regnum == ARM_PC_REGNUM || regnum == -1)
504 {
505 reg_pc = extract_unsigned_integer (gregs
506 + INT_REGISTER_SIZE * ARM_PC_REGNUM,
507 INT_REGISTER_SIZE, byte_order);
508 reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
509 store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
510 regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
511 }
512 }
513
514 void
515 arm_linux_collect_gregset (const struct regset *regset,
516 const struct regcache *regcache,
517 int regnum, void *gregs_buf, size_t len)
518 {
519 gdb_byte *gregs = (gdb_byte *) gregs_buf;
520 int regno;
521
522 for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
523 if (regnum == -1 || regnum == regno)
524 regcache_raw_collect (regcache, regno,
525 gregs + INT_REGISTER_SIZE * regno);
526
527 if (regnum == ARM_PS_REGNUM || regnum == -1)
528 {
529 if (arm_apcs_32)
530 regcache_raw_collect (regcache, ARM_PS_REGNUM,
531 gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
532 else
533 regcache_raw_collect (regcache, ARM_PS_REGNUM,
534 gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
535 }
536
537 if (regnum == ARM_PC_REGNUM || regnum == -1)
538 regcache_raw_collect (regcache, ARM_PC_REGNUM,
539 gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
540 }
541
542 /* Support for register format used by the NWFPE FPA emulator. */
543
544 #define typeNone 0x00
545 #define typeSingle 0x01
546 #define typeDouble 0x02
547 #define typeExtended 0x03
548
549 void
550 supply_nwfpe_register (struct regcache *regcache, int regno,
551 const gdb_byte *regs)
552 {
553 const gdb_byte *reg_data;
554 gdb_byte reg_tag;
555 gdb_byte buf[FP_REGISTER_SIZE];
556
557 reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
558 reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
559 memset (buf, 0, FP_REGISTER_SIZE);
560
561 switch (reg_tag)
562 {
563 case typeSingle:
564 memcpy (buf, reg_data, 4);
565 break;
566 case typeDouble:
567 memcpy (buf, reg_data + 4, 4);
568 memcpy (buf + 4, reg_data, 4);
569 break;
570 case typeExtended:
571 /* We want sign and exponent, then least significant bits,
572 then most significant. NWFPE does sign, most, least. */
573 memcpy (buf, reg_data, 4);
574 memcpy (buf + 4, reg_data + 8, 4);
575 memcpy (buf + 8, reg_data + 4, 4);
576 break;
577 default:
578 break;
579 }
580
581 regcache_raw_supply (regcache, regno, buf);
582 }
583
584 void
585 collect_nwfpe_register (const struct regcache *regcache, int regno,
586 gdb_byte *regs)
587 {
588 gdb_byte *reg_data;
589 gdb_byte reg_tag;
590 gdb_byte buf[FP_REGISTER_SIZE];
591
592 regcache_raw_collect (regcache, regno, buf);
593
594 /* NOTE drow/2006-06-07: This code uses the tag already in the
595 register buffer. I've preserved that when moving the code
596 from the native file to the target file. But this doesn't
597 always make sense. */
598
599 reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
600 reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
601
602 switch (reg_tag)
603 {
604 case typeSingle:
605 memcpy (reg_data, buf, 4);
606 break;
607 case typeDouble:
608 memcpy (reg_data, buf + 4, 4);
609 memcpy (reg_data + 4, buf, 4);
610 break;
611 case typeExtended:
612 memcpy (reg_data, buf, 4);
613 memcpy (reg_data + 4, buf + 8, 4);
614 memcpy (reg_data + 8, buf + 4, 4);
615 break;
616 default:
617 break;
618 }
619 }
620
621 void
622 arm_linux_supply_nwfpe (const struct regset *regset,
623 struct regcache *regcache,
624 int regnum, const void *regs_buf, size_t len)
625 {
626 const gdb_byte *regs = (const gdb_byte *) regs_buf;
627 int regno;
628
629 if (regnum == ARM_FPS_REGNUM || regnum == -1)
630 regcache_raw_supply (regcache, ARM_FPS_REGNUM,
631 regs + NWFPE_FPSR_OFFSET);
632
633 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
634 if (regnum == -1 || regnum == regno)
635 supply_nwfpe_register (regcache, regno, regs);
636 }
637
638 void
639 arm_linux_collect_nwfpe (const struct regset *regset,
640 const struct regcache *regcache,
641 int regnum, void *regs_buf, size_t len)
642 {
643 gdb_byte *regs = (gdb_byte *) regs_buf;
644 int regno;
645
646 for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
647 if (regnum == -1 || regnum == regno)
648 collect_nwfpe_register (regcache, regno, regs);
649
650 if (regnum == ARM_FPS_REGNUM || regnum == -1)
651 regcache_raw_collect (regcache, ARM_FPS_REGNUM,
652 regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
653 }
654
655 /* Support VFP register format. */
656
657 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
658
659 static void
660 arm_linux_supply_vfp (const struct regset *regset,
661 struct regcache *regcache,
662 int regnum, const void *regs_buf, size_t len)
663 {
664 const gdb_byte *regs = (const gdb_byte *) regs_buf;
665 int regno;
666
667 if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
668 regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
669
670 for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
671 if (regnum == -1 || regnum == regno)
672 regcache_raw_supply (regcache, regno,
673 regs + (regno - ARM_D0_REGNUM) * 8);
674 }
675
676 static void
677 arm_linux_collect_vfp (const struct regset *regset,
678 const struct regcache *regcache,
679 int regnum, void *regs_buf, size_t len)
680 {
681 gdb_byte *regs = (gdb_byte *) regs_buf;
682 int regno;
683
684 if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
685 regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
686
687 for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
688 if (regnum == -1 || regnum == regno)
689 regcache_raw_collect (regcache, regno,
690 regs + (regno - ARM_D0_REGNUM) * 8);
691 }
692
693 static const struct regset arm_linux_gregset =
694 {
695 NULL, arm_linux_supply_gregset, arm_linux_collect_gregset
696 };
697
698 static const struct regset arm_linux_fpregset =
699 {
700 NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe
701 };
702
703 static const struct regset arm_linux_vfpregset =
704 {
705 NULL, arm_linux_supply_vfp, arm_linux_collect_vfp
706 };
707
708 /* Iterate over core file register note sections. */
709
710 static void
711 arm_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
712 iterate_over_regset_sections_cb *cb,
713 void *cb_data,
714 const struct regcache *regcache)
715 {
716 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
717
718 cb (".reg", ARM_LINUX_SIZEOF_GREGSET, &arm_linux_gregset, NULL, cb_data);
719
720 if (tdep->vfp_register_count > 0)
721 cb (".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP, &arm_linux_vfpregset,
722 "VFP floating-point", cb_data);
723 else if (tdep->have_fpa_registers)
724 cb (".reg2", ARM_LINUX_SIZEOF_NWFPE, &arm_linux_fpregset,
725 "FPA floating-point", cb_data);
726 }
727
728 /* Determine target description from core file. */
729
730 static const struct target_desc *
731 arm_linux_core_read_description (struct gdbarch *gdbarch,
732 struct target_ops *target,
733 bfd *abfd)
734 {
735 CORE_ADDR arm_hwcap = 0;
736
737 if (target_auxv_search (target, AT_HWCAP, &arm_hwcap) != 1)
738 return NULL;
739
740 if (arm_hwcap & HWCAP_VFP)
741 {
742 /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
743 Neon with VFPv3-D32. */
744 if (arm_hwcap & HWCAP_NEON)
745 return tdesc_arm_with_neon;
746 else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
747 return tdesc_arm_with_vfpv3;
748 else
749 return tdesc_arm_with_vfpv2;
750 }
751
752 return NULL;
753 }
754
755
756 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
757 return 1. In addition, set IS_THUMB depending on whether we
758 will return to ARM or Thumb code. Return 0 if it is not a
759 rt_sigreturn/sigreturn syscall. */
760 static int
761 arm_linux_sigreturn_return_addr (struct frame_info *frame,
762 unsigned long svc_number,
763 CORE_ADDR *pc, int *is_thumb)
764 {
765 /* Is this a sigreturn or rt_sigreturn syscall? */
766 if (svc_number == 119 || svc_number == 173)
767 {
768 if (get_frame_type (frame) == SIGTRAMP_FRAME)
769 {
770 ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame));
771 CORE_ADDR cpsr
772 = frame_unwind_register_unsigned (frame, ARM_PS_REGNUM);
773
774 *is_thumb = (cpsr & t_bit) != 0;
775 *pc = frame_unwind_caller_pc (frame);
776 return 1;
777 }
778 }
779 return 0;
780 }
781
782 /* Find the value of the next PC after a sigreturn or rt_sigreturn syscall
783 based on current processor state. In addition, set IS_THUMB depending
784 on whether we will return to ARM or Thumb code. */
785
786 static CORE_ADDR
787 arm_linux_sigreturn_next_pc (struct regcache *regcache,
788 unsigned long svc_number, int *is_thumb)
789 {
790 ULONGEST sp;
791 unsigned long sp_data;
792 CORE_ADDR next_pc = 0;
793 struct gdbarch *gdbarch = regcache->arch ();
794 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
795 int pc_offset = 0;
796 int is_sigreturn = 0;
797 CORE_ADDR cpsr;
798
799 gdb_assert (svc_number == ARM_SIGRETURN
800 || svc_number == ARM_RT_SIGRETURN);
801
802 is_sigreturn = (svc_number == ARM_SIGRETURN);
803 regcache_cooked_read_unsigned (regcache, ARM_SP_REGNUM, &sp);
804 sp_data = read_memory_unsigned_integer (sp, 4, byte_order);
805
806 pc_offset = arm_linux_sigreturn_next_pc_offset (sp, sp_data, svc_number,
807 is_sigreturn);
808
809 next_pc = read_memory_unsigned_integer (sp + pc_offset, 4, byte_order);
810
811 /* Set IS_THUMB according the CPSR saved on the stack. */
812 cpsr = read_memory_unsigned_integer (sp + pc_offset + 4, 4, byte_order);
813 *is_thumb = ((cpsr & arm_psr_thumb_bit (gdbarch)) != 0);
814
815 return next_pc;
816 }
817
818 /* At a ptrace syscall-stop, return the syscall number. This either
819 comes from the SWI instruction (OABI) or from r7 (EABI).
820
821 When the function fails, it should return -1. */
822
823 static LONGEST
824 arm_linux_get_syscall_number (struct gdbarch *gdbarch,
825 ptid_t ptid)
826 {
827 struct regcache *regs = get_thread_regcache (ptid);
828
829 ULONGEST pc;
830 ULONGEST cpsr;
831 ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
832 int is_thumb;
833 ULONGEST svc_number = -1;
834
835 regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc);
836 regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr);
837 is_thumb = (cpsr & t_bit) != 0;
838
839 if (is_thumb)
840 {
841 regcache_cooked_read_unsigned (regs, 7, &svc_number);
842 }
843 else
844 {
845 enum bfd_endian byte_order_for_code =
846 gdbarch_byte_order_for_code (gdbarch);
847
848 /* PC gets incremented before the syscall-stop, so read the
849 previous instruction. */
850 unsigned long this_instr =
851 read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);
852
853 unsigned long svc_operand = (0x00ffffff & this_instr);
854
855 if (svc_operand)
856 {
857 /* OABI */
858 svc_number = svc_operand - 0x900000;
859 }
860 else
861 {
862 /* EABI */
863 regcache_cooked_read_unsigned (regs, 7, &svc_number);
864 }
865 }
866
867 return svc_number;
868 }
869
870 static CORE_ADDR
871 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self)
872 {
873 CORE_ADDR next_pc = 0;
874 CORE_ADDR pc = regcache_read_pc (self->regcache);
875 int is_thumb = arm_is_thumb (self->regcache);
876 ULONGEST svc_number = 0;
877
878 if (is_thumb)
879 {
880 svc_number = regcache_raw_get_unsigned (self->regcache, 7);
881 next_pc = pc + 2;
882 }
883 else
884 {
885 struct gdbarch *gdbarch = self->regcache->arch ();
886 enum bfd_endian byte_order_for_code =
887 gdbarch_byte_order_for_code (gdbarch);
888 unsigned long this_instr =
889 read_memory_unsigned_integer (pc, 4, byte_order_for_code);
890
891 unsigned long svc_operand = (0x00ffffff & this_instr);
892 if (svc_operand) /* OABI. */
893 {
894 svc_number = svc_operand - 0x900000;
895 }
896 else /* EABI. */
897 {
898 svc_number = regcache_raw_get_unsigned (self->regcache, 7);
899 }
900
901 next_pc = pc + 4;
902 }
903
904 if (svc_number == ARM_SIGRETURN || svc_number == ARM_RT_SIGRETURN)
905 {
906 /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
907 update IS_THUMB. */
908 next_pc = arm_linux_sigreturn_next_pc (self->regcache, svc_number,
909 &is_thumb);
910 }
911
912 /* Addresses for calling Thumb functions have the bit 0 set. */
913 if (is_thumb)
914 next_pc = MAKE_THUMB_ADDR (next_pc);
915
916 return next_pc;
917 }
918
919
920 /* Insert a single step breakpoint at the next executed instruction. */
921
922 static std::vector<CORE_ADDR>
923 arm_linux_software_single_step (struct regcache *regcache)
924 {
925 struct gdbarch *gdbarch = regcache->arch ();
926 struct arm_get_next_pcs next_pcs_ctx;
927
928 /* If the target does have hardware single step, GDB doesn't have
929 to bother software single step. */
930 if (target_can_do_single_step () == 1)
931 return {};
932
933 arm_get_next_pcs_ctor (&next_pcs_ctx,
934 &arm_linux_get_next_pcs_ops,
935 gdbarch_byte_order (gdbarch),
936 gdbarch_byte_order_for_code (gdbarch),
937 1,
938 regcache);
939
940 std::vector<CORE_ADDR> next_pcs = arm_get_next_pcs (&next_pcs_ctx);
941
942 for (CORE_ADDR &pc_ref : next_pcs)
943 pc_ref = gdbarch_addr_bits_remove (gdbarch, pc_ref);
944
945 return next_pcs;
946 }
947
948 /* Support for displaced stepping of Linux SVC instructions. */
949
950 static void
951 arm_linux_cleanup_svc (struct gdbarch *gdbarch,
952 struct regcache *regs,
953 arm_displaced_step_closure *dsc)
954 {
955 ULONGEST apparent_pc;
956 int within_scratch;
957
958 regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
959
960 within_scratch = (apparent_pc >= dsc->scratch_base
961 && apparent_pc < (dsc->scratch_base
962 + DISPLACED_MODIFIED_INSNS * 4 + 4));
963
964 if (debug_displaced)
965 {
966 fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
967 "SVC step ", (unsigned long) apparent_pc);
968 if (within_scratch)
969 fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
970 else
971 fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
972 }
973
974 if (within_scratch)
975 displaced_write_reg (regs, dsc, ARM_PC_REGNUM,
976 dsc->insn_addr + dsc->insn_size, BRANCH_WRITE_PC);
977 }
978
979 static int
980 arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
981 arm_displaced_step_closure *dsc)
982 {
983 CORE_ADDR return_to = 0;
984
985 struct frame_info *frame;
986 unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
987 int is_sigreturn = 0;
988 int is_thumb;
989
990 frame = get_current_frame ();
991
992 is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
993 &return_to, &is_thumb);
994 if (is_sigreturn)
995 {
996 struct symtab_and_line sal;
997
998 if (debug_displaced)
999 fprintf_unfiltered (gdb_stdlog, "displaced: found "
1000 "sigreturn/rt_sigreturn SVC call. PC in "
1001 "frame = %lx\n",
1002 (unsigned long) get_frame_pc (frame));
1003
1004 if (debug_displaced)
1005 fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
1006 "Setting momentary breakpoint.\n",
1007 (unsigned long) return_to);
1008
1009 gdb_assert (inferior_thread ()->control.step_resume_breakpoint
1010 == NULL);
1011
1012 sal = find_pc_line (return_to, 0);
1013 sal.pc = return_to;
1014 sal.section = find_pc_overlay (return_to);
1015 sal.explicit_pc = 1;
1016
1017 frame = get_prev_frame (frame);
1018
1019 if (frame)
1020 {
1021 inferior_thread ()->control.step_resume_breakpoint
1022 = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
1023 bp_step_resume).release ();
1024
1025 /* set_momentary_breakpoint invalidates FRAME. */
1026 frame = NULL;
1027
1028 /* We need to make sure we actually insert the momentary
1029 breakpoint set above. */
1030 insert_breakpoints ();
1031 }
1032 else if (debug_displaced)
1033 fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
1034 "frame to set momentary breakpoint for "
1035 "sigreturn/rt_sigreturn\n");
1036 }
1037 else if (debug_displaced)
1038 fprintf_unfiltered (gdb_stdlog, "displaced: found SVC call\n");
1039
1040 /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1041 location, else nothing.
1042 Insn: unmodified svc.
1043 Cleanup: if pc lands in scratch space, pc <- insn_addr + insn_size
1044 else leave pc alone. */
1045
1046
1047 dsc->cleanup = &arm_linux_cleanup_svc;
1048 /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1049 instruction. */
1050 dsc->wrote_to_pc = 1;
1051
1052 return 0;
1053 }
1054
1055
1056 /* The following two functions implement single-stepping over calls to Linux
1057 kernel helper routines, which perform e.g. atomic operations on architecture
1058 variants which don't support them natively.
1059
1060 When this function is called, the PC will be pointing at the kernel helper
1061 (at an address inaccessible to GDB), and r14 will point to the return
1062 address. Displaced stepping always executes code in the copy area:
1063 so, make the copy-area instruction branch back to the kernel helper (the
1064 "from" address), and make r14 point to the breakpoint in the copy area. In
1065 that way, we regain control once the kernel helper returns, and can clean
1066 up appropriately (as if we had just returned from the kernel helper as it
1067 would have been called from the non-displaced location). */
1068
1069 static void
1070 cleanup_kernel_helper_return (struct gdbarch *gdbarch,
1071 struct regcache *regs,
1072 arm_displaced_step_closure *dsc)
1073 {
1074 displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
1075 displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
1076 }
1077
1078 static void
1079 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
1080 CORE_ADDR to, struct regcache *regs,
1081 arm_displaced_step_closure *dsc)
1082 {
1083 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1084
1085 dsc->numinsns = 1;
1086 dsc->insn_addr = from;
1087 dsc->cleanup = &cleanup_kernel_helper_return;
1088 /* Say we wrote to the PC, else cleanup will set PC to the next
1089 instruction in the helper, which isn't helpful. */
1090 dsc->wrote_to_pc = 1;
1091
1092 /* Preparation: tmp[0] <- r14
1093 r14 <- <scratch space>+4
1094 *(<scratch space>+8) <- from
1095 Insn: ldr pc, [r14, #4]
1096 Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
1097
1098 dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM);
1099 displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
1100 CANNOT_WRITE_PC);
1101 write_memory_unsigned_integer (to + 8, 4, byte_order, from);
1102
1103 dsc->modinsn[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
1104 }
1105
1106 /* Linux-specific displaced step instruction copying function. Detects when
1107 the program has stepped into a Linux kernel helper routine (which must be
1108 handled as a special case). */
1109
1110 static struct displaced_step_closure *
1111 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
1112 CORE_ADDR from, CORE_ADDR to,
1113 struct regcache *regs)
1114 {
1115 arm_displaced_step_closure *dsc = new arm_displaced_step_closure;
1116
1117 /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1118 stop at the return location. */
1119 if (from > 0xffff0000)
1120 {
1121 if (debug_displaced)
1122 fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
1123 "at %.8lx\n", (unsigned long) from);
1124
1125 arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
1126 }
1127 else
1128 {
1129 /* Override the default handling of SVC instructions. */
1130 dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
1131
1132 arm_process_displaced_insn (gdbarch, from, to, regs, dsc);
1133 }
1134
1135 arm_displaced_init_closure (gdbarch, from, to, dsc);
1136
1137 return dsc;
1138 }
1139
1140 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1141 gdbarch.h. */
1142
1143 static int
1144 arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
1145 {
1146 return (*s == '#' || *s == '$' || isdigit (*s) /* Literal number. */
1147 || *s == '[' /* Register indirection or
1148 displacement. */
1149 || isalpha (*s)); /* Register value. */
1150 }
1151
1152 /* This routine is used to parse a special token in ARM's assembly.
1153
1154 The special tokens parsed by it are:
1155
1156 - Register displacement (e.g, [fp, #-8])
1157
1158 It returns one if the special token has been parsed successfully,
1159 or zero if the current token is not considered special. */
1160
1161 static int
1162 arm_stap_parse_special_token (struct gdbarch *gdbarch,
1163 struct stap_parse_info *p)
1164 {
1165 if (*p->arg == '[')
1166 {
1167 /* Temporary holder for lookahead. */
1168 const char *tmp = p->arg;
1169 char *endp;
1170 /* Used to save the register name. */
1171 const char *start;
1172 char *regname;
1173 int len, offset;
1174 int got_minus = 0;
1175 long displacement;
1176 struct stoken str;
1177
1178 ++tmp;
1179 start = tmp;
1180
1181 /* Register name. */
1182 while (isalnum (*tmp))
1183 ++tmp;
1184
1185 if (*tmp != ',')
1186 return 0;
1187
1188 len = tmp - start;
1189 regname = (char *) alloca (len + 2);
1190
1191 offset = 0;
1192 if (isdigit (*start))
1193 {
1194 /* If we are dealing with a register whose name begins with a
1195 digit, it means we should prefix the name with the letter
1196 `r', because GDB expects this name pattern. Otherwise (e.g.,
1197 we are dealing with the register `fp'), we don't need to
1198 add such a prefix. */
1199 regname[0] = 'r';
1200 offset = 1;
1201 }
1202
1203 strncpy (regname + offset, start, len);
1204 len += offset;
1205 regname[len] = '\0';
1206
1207 if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
1208 error (_("Invalid register name `%s' on expression `%s'."),
1209 regname, p->saved_arg);
1210
1211 ++tmp;
1212 tmp = skip_spaces (tmp);
1213 if (*tmp == '#' || *tmp == '$')
1214 ++tmp;
1215
1216 if (*tmp == '-')
1217 {
1218 ++tmp;
1219 got_minus = 1;
1220 }
1221
1222 displacement = strtol (tmp, &endp, 10);
1223 tmp = endp;
1224
1225 /* Skipping last `]'. */
1226 if (*tmp++ != ']')
1227 return 0;
1228
1229 /* The displacement. */
1230 write_exp_elt_opcode (&p->pstate, OP_LONG);
1231 write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
1232 write_exp_elt_longcst (&p->pstate, displacement);
1233 write_exp_elt_opcode (&p->pstate, OP_LONG);
1234 if (got_minus)
1235 write_exp_elt_opcode (&p->pstate, UNOP_NEG);
1236
1237 /* The register name. */
1238 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1239 str.ptr = regname;
1240 str.length = len;
1241 write_exp_string (&p->pstate, str);
1242 write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1243
1244 write_exp_elt_opcode (&p->pstate, BINOP_ADD);
1245
1246 /* Casting to the expected type. */
1247 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1248 write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
1249 write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1250
1251 write_exp_elt_opcode (&p->pstate, UNOP_IND);
1252
1253 p->arg = tmp;
1254 }
1255 else
1256 return 0;
1257
1258 return 1;
1259 }
1260
1261 /* ARM process record-replay constructs: syscall, signal etc. */
1262
1263 struct linux_record_tdep arm_linux_record_tdep;
1264
1265 /* arm_canonicalize_syscall maps from the native arm Linux set
1266 of syscall ids into a canonical set of syscall ids used by
1267 process record. */
1268
1269 static enum gdb_syscall
1270 arm_canonicalize_syscall (int syscall)
1271 {
1272 switch (syscall)
1273 {
1274 case 0: return gdb_sys_restart_syscall;
1275 case 1: return gdb_sys_exit;
1276 case 2: return gdb_sys_fork;
1277 case 3: return gdb_sys_read;
1278 case 4: return gdb_sys_write;
1279 case 5: return gdb_sys_open;
1280 case 6: return gdb_sys_close;
1281 case 8: return gdb_sys_creat;
1282 case 9: return gdb_sys_link;
1283 case 10: return gdb_sys_unlink;
1284 case 11: return gdb_sys_execve;
1285 case 12: return gdb_sys_chdir;
1286 case 13: return gdb_sys_time;
1287 case 14: return gdb_sys_mknod;
1288 case 15: return gdb_sys_chmod;
1289 case 16: return gdb_sys_lchown16;
1290 case 19: return gdb_sys_lseek;
1291 case 20: return gdb_sys_getpid;
1292 case 21: return gdb_sys_mount;
1293 case 22: return gdb_sys_oldumount;
1294 case 23: return gdb_sys_setuid16;
1295 case 24: return gdb_sys_getuid16;
1296 case 25: return gdb_sys_stime;
1297 case 26: return gdb_sys_ptrace;
1298 case 27: return gdb_sys_alarm;
1299 case 29: return gdb_sys_pause;
1300 case 30: return gdb_sys_utime;
1301 case 33: return gdb_sys_access;
1302 case 34: return gdb_sys_nice;
1303 case 36: return gdb_sys_sync;
1304 case 37: return gdb_sys_kill;
1305 case 38: return gdb_sys_rename;
1306 case 39: return gdb_sys_mkdir;
1307 case 40: return gdb_sys_rmdir;
1308 case 41: return gdb_sys_dup;
1309 case 42: return gdb_sys_pipe;
1310 case 43: return gdb_sys_times;
1311 case 45: return gdb_sys_brk;
1312 case 46: return gdb_sys_setgid16;
1313 case 47: return gdb_sys_getgid16;
1314 case 49: return gdb_sys_geteuid16;
1315 case 50: return gdb_sys_getegid16;
1316 case 51: return gdb_sys_acct;
1317 case 52: return gdb_sys_umount;
1318 case 54: return gdb_sys_ioctl;
1319 case 55: return gdb_sys_fcntl;
1320 case 57: return gdb_sys_setpgid;
1321 case 60: return gdb_sys_umask;
1322 case 61: return gdb_sys_chroot;
1323 case 62: return gdb_sys_ustat;
1324 case 63: return gdb_sys_dup2;
1325 case 64: return gdb_sys_getppid;
1326 case 65: return gdb_sys_getpgrp;
1327 case 66: return gdb_sys_setsid;
1328 case 67: return gdb_sys_sigaction;
1329 case 70: return gdb_sys_setreuid16;
1330 case 71: return gdb_sys_setregid16;
1331 case 72: return gdb_sys_sigsuspend;
1332 case 73: return gdb_sys_sigpending;
1333 case 74: return gdb_sys_sethostname;
1334 case 75: return gdb_sys_setrlimit;
1335 case 76: return gdb_sys_getrlimit;
1336 case 77: return gdb_sys_getrusage;
1337 case 78: return gdb_sys_gettimeofday;
1338 case 79: return gdb_sys_settimeofday;
1339 case 80: return gdb_sys_getgroups16;
1340 case 81: return gdb_sys_setgroups16;
1341 case 82: return gdb_sys_select;
1342 case 83: return gdb_sys_symlink;
1343 case 85: return gdb_sys_readlink;
1344 case 86: return gdb_sys_uselib;
1345 case 87: return gdb_sys_swapon;
1346 case 88: return gdb_sys_reboot;
1347 case 89: return gdb_old_readdir;
1348 case 90: return gdb_old_mmap;
1349 case 91: return gdb_sys_munmap;
1350 case 92: return gdb_sys_truncate;
1351 case 93: return gdb_sys_ftruncate;
1352 case 94: return gdb_sys_fchmod;
1353 case 95: return gdb_sys_fchown16;
1354 case 96: return gdb_sys_getpriority;
1355 case 97: return gdb_sys_setpriority;
1356 case 99: return gdb_sys_statfs;
1357 case 100: return gdb_sys_fstatfs;
1358 case 102: return gdb_sys_socketcall;
1359 case 103: return gdb_sys_syslog;
1360 case 104: return gdb_sys_setitimer;
1361 case 105: return gdb_sys_getitimer;
1362 case 106: return gdb_sys_stat;
1363 case 107: return gdb_sys_lstat;
1364 case 108: return gdb_sys_fstat;
1365 case 111: return gdb_sys_vhangup;
1366 case 113: /* sys_syscall */
1367 return gdb_sys_no_syscall;
1368 case 114: return gdb_sys_wait4;
1369 case 115: return gdb_sys_swapoff;
1370 case 116: return gdb_sys_sysinfo;
1371 case 117: return gdb_sys_ipc;
1372 case 118: return gdb_sys_fsync;
1373 case 119: return gdb_sys_sigreturn;
1374 case 120: return gdb_sys_clone;
1375 case 121: return gdb_sys_setdomainname;
1376 case 122: return gdb_sys_uname;
1377 case 124: return gdb_sys_adjtimex;
1378 case 125: return gdb_sys_mprotect;
1379 case 126: return gdb_sys_sigprocmask;
1380 case 128: return gdb_sys_init_module;
1381 case 129: return gdb_sys_delete_module;
1382 case 131: return gdb_sys_quotactl;
1383 case 132: return gdb_sys_getpgid;
1384 case 133: return gdb_sys_fchdir;
1385 case 134: return gdb_sys_bdflush;
1386 case 135: return gdb_sys_sysfs;
1387 case 136: return gdb_sys_personality;
1388 case 138: return gdb_sys_setfsuid16;
1389 case 139: return gdb_sys_setfsgid16;
1390 case 140: return gdb_sys_llseek;
1391 case 141: return gdb_sys_getdents;
1392 case 142: return gdb_sys_select;
1393 case 143: return gdb_sys_flock;
1394 case 144: return gdb_sys_msync;
1395 case 145: return gdb_sys_readv;
1396 case 146: return gdb_sys_writev;
1397 case 147: return gdb_sys_getsid;
1398 case 148: return gdb_sys_fdatasync;
1399 case 149: return gdb_sys_sysctl;
1400 case 150: return gdb_sys_mlock;
1401 case 151: return gdb_sys_munlock;
1402 case 152: return gdb_sys_mlockall;
1403 case 153: return gdb_sys_munlockall;
1404 case 154: return gdb_sys_sched_setparam;
1405 case 155: return gdb_sys_sched_getparam;
1406 case 156: return gdb_sys_sched_setscheduler;
1407 case 157: return gdb_sys_sched_getscheduler;
1408 case 158: return gdb_sys_sched_yield;
1409 case 159: return gdb_sys_sched_get_priority_max;
1410 case 160: return gdb_sys_sched_get_priority_min;
1411 case 161: return gdb_sys_sched_rr_get_interval;
1412 case 162: return gdb_sys_nanosleep;
1413 case 163: return gdb_sys_mremap;
1414 case 164: return gdb_sys_setresuid16;
1415 case 165: return gdb_sys_getresuid16;
1416 case 168: return gdb_sys_poll;
1417 case 169: return gdb_sys_nfsservctl;
1418 case 170: return gdb_sys_setresgid;
1419 case 171: return gdb_sys_getresgid;
1420 case 172: return gdb_sys_prctl;
1421 case 173: return gdb_sys_rt_sigreturn;
1422 case 174: return gdb_sys_rt_sigaction;
1423 case 175: return gdb_sys_rt_sigprocmask;
1424 case 176: return gdb_sys_rt_sigpending;
1425 case 177: return gdb_sys_rt_sigtimedwait;
1426 case 178: return gdb_sys_rt_sigqueueinfo;
1427 case 179: return gdb_sys_rt_sigsuspend;
1428 case 180: return gdb_sys_pread64;
1429 case 181: return gdb_sys_pwrite64;
1430 case 182: return gdb_sys_chown;
1431 case 183: return gdb_sys_getcwd;
1432 case 184: return gdb_sys_capget;
1433 case 185: return gdb_sys_capset;
1434 case 186: return gdb_sys_sigaltstack;
1435 case 187: return gdb_sys_sendfile;
1436 case 190: return gdb_sys_vfork;
1437 case 191: return gdb_sys_getrlimit;
1438 case 192: return gdb_sys_mmap2;
1439 case 193: return gdb_sys_truncate64;
1440 case 194: return gdb_sys_ftruncate64;
1441 case 195: return gdb_sys_stat64;
1442 case 196: return gdb_sys_lstat64;
1443 case 197: return gdb_sys_fstat64;
1444 case 198: return gdb_sys_lchown;
1445 case 199: return gdb_sys_getuid;
1446 case 200: return gdb_sys_getgid;
1447 case 201: return gdb_sys_geteuid;
1448 case 202: return gdb_sys_getegid;
1449 case 203: return gdb_sys_setreuid;
1450 case 204: return gdb_sys_setregid;
1451 case 205: return gdb_sys_getgroups;
1452 case 206: return gdb_sys_setgroups;
1453 case 207: return gdb_sys_fchown;
1454 case 208: return gdb_sys_setresuid;
1455 case 209: return gdb_sys_getresuid;
1456 case 210: return gdb_sys_setresgid;
1457 case 211: return gdb_sys_getresgid;
1458 case 212: return gdb_sys_chown;
1459 case 213: return gdb_sys_setuid;
1460 case 214: return gdb_sys_setgid;
1461 case 215: return gdb_sys_setfsuid;
1462 case 216: return gdb_sys_setfsgid;
1463 case 217: return gdb_sys_getdents64;
1464 case 218: return gdb_sys_pivot_root;
1465 case 219: return gdb_sys_mincore;
1466 case 220: return gdb_sys_madvise;
1467 case 221: return gdb_sys_fcntl64;
1468 case 224: return gdb_sys_gettid;
1469 case 225: return gdb_sys_readahead;
1470 case 226: return gdb_sys_setxattr;
1471 case 227: return gdb_sys_lsetxattr;
1472 case 228: return gdb_sys_fsetxattr;
1473 case 229: return gdb_sys_getxattr;
1474 case 230: return gdb_sys_lgetxattr;
1475 case 231: return gdb_sys_fgetxattr;
1476 case 232: return gdb_sys_listxattr;
1477 case 233: return gdb_sys_llistxattr;
1478 case 234: return gdb_sys_flistxattr;
1479 case 235: return gdb_sys_removexattr;
1480 case 236: return gdb_sys_lremovexattr;
1481 case 237: return gdb_sys_fremovexattr;
1482 case 238: return gdb_sys_tkill;
1483 case 239: return gdb_sys_sendfile64;
1484 case 240: return gdb_sys_futex;
1485 case 241: return gdb_sys_sched_setaffinity;
1486 case 242: return gdb_sys_sched_getaffinity;
1487 case 243: return gdb_sys_io_setup;
1488 case 244: return gdb_sys_io_destroy;
1489 case 245: return gdb_sys_io_getevents;
1490 case 246: return gdb_sys_io_submit;
1491 case 247: return gdb_sys_io_cancel;
1492 case 248: return gdb_sys_exit_group;
1493 case 249: return gdb_sys_lookup_dcookie;
1494 case 250: return gdb_sys_epoll_create;
1495 case 251: return gdb_sys_epoll_ctl;
1496 case 252: return gdb_sys_epoll_wait;
1497 case 253: return gdb_sys_remap_file_pages;
1498 case 256: return gdb_sys_set_tid_address;
1499 case 257: return gdb_sys_timer_create;
1500 case 258: return gdb_sys_timer_settime;
1501 case 259: return gdb_sys_timer_gettime;
1502 case 260: return gdb_sys_timer_getoverrun;
1503 case 261: return gdb_sys_timer_delete;
1504 case 262: return gdb_sys_clock_settime;
1505 case 263: return gdb_sys_clock_gettime;
1506 case 264: return gdb_sys_clock_getres;
1507 case 265: return gdb_sys_clock_nanosleep;
1508 case 266: return gdb_sys_statfs64;
1509 case 267: return gdb_sys_fstatfs64;
1510 case 268: return gdb_sys_tgkill;
1511 case 269: return gdb_sys_utimes;
1512 /*
1513 case 270: return gdb_sys_arm_fadvise64_64;
1514 case 271: return gdb_sys_pciconfig_iobase;
1515 case 272: return gdb_sys_pciconfig_read;
1516 case 273: return gdb_sys_pciconfig_write;
1517 */
1518 case 274: return gdb_sys_mq_open;
1519 case 275: return gdb_sys_mq_unlink;
1520 case 276: return gdb_sys_mq_timedsend;
1521 case 277: return gdb_sys_mq_timedreceive;
1522 case 278: return gdb_sys_mq_notify;
1523 case 279: return gdb_sys_mq_getsetattr;
1524 case 280: return gdb_sys_waitid;
1525 case 281: return gdb_sys_socket;
1526 case 282: return gdb_sys_bind;
1527 case 283: return gdb_sys_connect;
1528 case 284: return gdb_sys_listen;
1529 case 285: return gdb_sys_accept;
1530 case 286: return gdb_sys_getsockname;
1531 case 287: return gdb_sys_getpeername;
1532 case 288: return gdb_sys_socketpair;
1533 case 289: /* send */ return gdb_sys_no_syscall;
1534 case 290: return gdb_sys_sendto;
1535 case 291: return gdb_sys_recv;
1536 case 292: return gdb_sys_recvfrom;
1537 case 293: return gdb_sys_shutdown;
1538 case 294: return gdb_sys_setsockopt;
1539 case 295: return gdb_sys_getsockopt;
1540 case 296: return gdb_sys_sendmsg;
1541 case 297: return gdb_sys_recvmsg;
1542 case 298: return gdb_sys_semop;
1543 case 299: return gdb_sys_semget;
1544 case 300: return gdb_sys_semctl;
1545 case 301: return gdb_sys_msgsnd;
1546 case 302: return gdb_sys_msgrcv;
1547 case 303: return gdb_sys_msgget;
1548 case 304: return gdb_sys_msgctl;
1549 case 305: return gdb_sys_shmat;
1550 case 306: return gdb_sys_shmdt;
1551 case 307: return gdb_sys_shmget;
1552 case 308: return gdb_sys_shmctl;
1553 case 309: return gdb_sys_add_key;
1554 case 310: return gdb_sys_request_key;
1555 case 311: return gdb_sys_keyctl;
1556 case 312: return gdb_sys_semtimedop;
1557 case 313: /* vserver */ return gdb_sys_no_syscall;
1558 case 314: return gdb_sys_ioprio_set;
1559 case 315: return gdb_sys_ioprio_get;
1560 case 316: return gdb_sys_inotify_init;
1561 case 317: return gdb_sys_inotify_add_watch;
1562 case 318: return gdb_sys_inotify_rm_watch;
1563 case 319: return gdb_sys_mbind;
1564 case 320: return gdb_sys_get_mempolicy;
1565 case 321: return gdb_sys_set_mempolicy;
1566 case 322: return gdb_sys_openat;
1567 case 323: return gdb_sys_mkdirat;
1568 case 324: return gdb_sys_mknodat;
1569 case 325: return gdb_sys_fchownat;
1570 case 326: return gdb_sys_futimesat;
1571 case 327: return gdb_sys_fstatat64;
1572 case 328: return gdb_sys_unlinkat;
1573 case 329: return gdb_sys_renameat;
1574 case 330: return gdb_sys_linkat;
1575 case 331: return gdb_sys_symlinkat;
1576 case 332: return gdb_sys_readlinkat;
1577 case 333: return gdb_sys_fchmodat;
1578 case 334: return gdb_sys_faccessat;
1579 case 335: return gdb_sys_pselect6;
1580 case 336: return gdb_sys_ppoll;
1581 case 337: return gdb_sys_unshare;
1582 case 338: return gdb_sys_set_robust_list;
1583 case 339: return gdb_sys_get_robust_list;
1584 case 340: return gdb_sys_splice;
1585 /*case 341: return gdb_sys_arm_sync_file_range;*/
1586 case 342: return gdb_sys_tee;
1587 case 343: return gdb_sys_vmsplice;
1588 case 344: return gdb_sys_move_pages;
1589 case 345: return gdb_sys_getcpu;
1590 case 346: return gdb_sys_epoll_pwait;
1591 case 347: return gdb_sys_kexec_load;
1592 /*
1593 case 348: return gdb_sys_utimensat;
1594 case 349: return gdb_sys_signalfd;
1595 case 350: return gdb_sys_timerfd_create;
1596 case 351: return gdb_sys_eventfd;
1597 */
1598 case 352: return gdb_sys_fallocate;
1599 /*
1600 case 353: return gdb_sys_timerfd_settime;
1601 case 354: return gdb_sys_timerfd_gettime;
1602 case 355: return gdb_sys_signalfd4;
1603 */
1604 case 356: return gdb_sys_eventfd2;
1605 case 357: return gdb_sys_epoll_create1;
1606 case 358: return gdb_sys_dup3;
1607 case 359: return gdb_sys_pipe2;
1608 case 360: return gdb_sys_inotify_init1;
1609 /*
1610 case 361: return gdb_sys_preadv;
1611 case 362: return gdb_sys_pwritev;
1612 case 363: return gdb_sys_rt_tgsigqueueinfo;
1613 case 364: return gdb_sys_perf_event_open;
1614 case 365: return gdb_sys_recvmmsg;
1615 case 366: return gdb_sys_accept4;
1616 case 367: return gdb_sys_fanotify_init;
1617 case 368: return gdb_sys_fanotify_mark;
1618 case 369: return gdb_sys_prlimit64;
1619 case 370: return gdb_sys_name_to_handle_at;
1620 case 371: return gdb_sys_open_by_handle_at;
1621 case 372: return gdb_sys_clock_adjtime;
1622 case 373: return gdb_sys_syncfs;
1623 case 374: return gdb_sys_sendmmsg;
1624 case 375: return gdb_sys_setns;
1625 case 376: return gdb_sys_process_vm_readv;
1626 case 377: return gdb_sys_process_vm_writev;
1627 case 378: return gdb_sys_kcmp;
1628 case 379: return gdb_sys_finit_module;
1629 */
1630 case 983041: /* ARM_breakpoint */ return gdb_sys_no_syscall;
1631 case 983042: /* ARM_cacheflush */ return gdb_sys_no_syscall;
1632 case 983043: /* ARM_usr26 */ return gdb_sys_no_syscall;
1633 case 983044: /* ARM_usr32 */ return gdb_sys_no_syscall;
1634 case 983045: /* ARM_set_tls */ return gdb_sys_no_syscall;
1635 default: return gdb_sys_no_syscall;
1636 }
1637 }
1638
1639 /* Record all registers but PC register for process-record. */
1640
1641 static int
1642 arm_all_but_pc_registers_record (struct regcache *regcache)
1643 {
1644 int i;
1645
1646 for (i = 0; i < ARM_PC_REGNUM; i++)
1647 {
1648 if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i))
1649 return -1;
1650 }
1651
1652 if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1653 return -1;
1654
1655 return 0;
1656 }
1657
1658 /* Handler for arm system call instruction recording. */
1659
1660 static int
1661 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number)
1662 {
1663 int ret = 0;
1664 enum gdb_syscall syscall_gdb;
1665
1666 syscall_gdb = arm_canonicalize_syscall (svc_number);
1667
1668 if (syscall_gdb == gdb_sys_no_syscall)
1669 {
1670 printf_unfiltered (_("Process record and replay target doesn't "
1671 "support syscall number %s\n"),
1672 plongest (svc_number));
1673 return -1;
1674 }
1675
1676 if (syscall_gdb == gdb_sys_sigreturn
1677 || syscall_gdb == gdb_sys_rt_sigreturn)
1678 {
1679 if (arm_all_but_pc_registers_record (regcache))
1680 return -1;
1681 return 0;
1682 }
1683
1684 ret = record_linux_system_call (syscall_gdb, regcache,
1685 &arm_linux_record_tdep);
1686 if (ret != 0)
1687 return ret;
1688
1689 /* Record the return value of the system call. */
1690 if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM))
1691 return -1;
1692 /* Record LR. */
1693 if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM))
1694 return -1;
1695 /* Record CPSR. */
1696 if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1697 return -1;
1698
1699 return 0;
1700 }
1701
1702 /* Implement the skip_trampoline_code gdbarch method. */
1703
1704 static CORE_ADDR
1705 arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1706 {
1707 CORE_ADDR target_pc = arm_skip_stub (frame, pc);
1708
1709 if (target_pc != 0)
1710 return target_pc;
1711
1712 return find_solib_trampoline_target (frame, pc);
1713 }
1714
1715 static void
1716 arm_linux_init_abi (struct gdbarch_info info,
1717 struct gdbarch *gdbarch)
1718 {
1719 static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL };
1720 static const char *const stap_register_prefixes[] = { "r", NULL };
1721 static const char *const stap_register_indirection_prefixes[] = { "[",
1722 NULL };
1723 static const char *const stap_register_indirection_suffixes[] = { "]",
1724 NULL };
1725 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1726
1727 linux_init_abi (info, gdbarch);
1728
1729 tdep->lowest_pc = 0x8000;
1730 if (info.byte_order_for_code == BFD_ENDIAN_BIG)
1731 {
1732 if (tdep->arm_abi == ARM_ABI_AAPCS)
1733 tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
1734 else
1735 tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
1736 tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
1737 tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
1738 }
1739 else
1740 {
1741 if (tdep->arm_abi == ARM_ABI_AAPCS)
1742 tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
1743 else
1744 tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
1745 tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
1746 tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
1747 }
1748 tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
1749 tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
1750 tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);
1751
1752 if (tdep->fp_model == ARM_FLOAT_AUTO)
1753 tdep->fp_model = ARM_FLOAT_FPA;
1754
1755 switch (tdep->fp_model)
1756 {
1757 case ARM_FLOAT_FPA:
1758 tdep->jb_pc = ARM_LINUX_JB_PC_FPA;
1759 break;
1760 case ARM_FLOAT_SOFT_FPA:
1761 case ARM_FLOAT_SOFT_VFP:
1762 case ARM_FLOAT_VFP:
1763 tdep->jb_pc = ARM_LINUX_JB_PC_EABI;
1764 break;
1765 default:
1766 internal_error
1767 (__FILE__, __LINE__,
1768 _("arm_linux_init_abi: Floating point model not supported"));
1769 break;
1770 }
1771 tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
1772
1773 set_solib_svr4_fetch_link_map_offsets
1774 (gdbarch, svr4_ilp32_fetch_link_map_offsets);
1775
1776 /* Single stepping. */
1777 set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
1778
1779 /* Shared library handling. */
1780 set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code);
1781 set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1782
1783 /* Enable TLS support. */
1784 set_gdbarch_fetch_tls_load_module_address (gdbarch,
1785 svr4_fetch_objfile_link_map);
1786
1787 tramp_frame_prepend_unwinder (gdbarch,
1788 &arm_linux_sigreturn_tramp_frame);
1789 tramp_frame_prepend_unwinder (gdbarch,
1790 &arm_linux_rt_sigreturn_tramp_frame);
1791 tramp_frame_prepend_unwinder (gdbarch,
1792 &arm_eabi_linux_sigreturn_tramp_frame);
1793 tramp_frame_prepend_unwinder (gdbarch,
1794 &arm_eabi_linux_rt_sigreturn_tramp_frame);
1795 tramp_frame_prepend_unwinder (gdbarch,
1796 &thumb2_eabi_linux_sigreturn_tramp_frame);
1797 tramp_frame_prepend_unwinder (gdbarch,
1798 &thumb2_eabi_linux_rt_sigreturn_tramp_frame);
1799 tramp_frame_prepend_unwinder (gdbarch,
1800 &arm_linux_restart_syscall_tramp_frame);
1801 tramp_frame_prepend_unwinder (gdbarch,
1802 &arm_kernel_linux_restart_syscall_tramp_frame);
1803
1804 /* Core file support. */
1805 set_gdbarch_iterate_over_regset_sections
1806 (gdbarch, arm_linux_iterate_over_regset_sections);
1807 set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description);
1808
1809 /* Displaced stepping. */
1810 set_gdbarch_displaced_step_copy_insn (gdbarch,
1811 arm_linux_displaced_step_copy_insn);
1812 set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
1813 set_gdbarch_displaced_step_location (gdbarch, linux_displaced_step_location);
1814
1815 /* Reversible debugging, process record. */
1816 set_gdbarch_process_record (gdbarch, arm_process_record);
1817
1818 /* SystemTap functions. */
1819 set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1820 set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1821 set_gdbarch_stap_register_indirection_prefixes (gdbarch,
1822 stap_register_indirection_prefixes);
1823 set_gdbarch_stap_register_indirection_suffixes (gdbarch,
1824 stap_register_indirection_suffixes);
1825 set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
1826 set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand);
1827 set_gdbarch_stap_parse_special_token (gdbarch,
1828 arm_stap_parse_special_token);
1829
1830 /* `catch syscall' */
1831 set_xml_syscall_file_name (gdbarch, "syscalls/arm-linux.xml");
1832 set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number);
1833
1834 /* Syscall record. */
1835 tdep->arm_syscall_record = arm_linux_syscall_record;
1836
1837 /* Initialize the arm_linux_record_tdep. */
1838 /* These values are the size of the type that will be used in a system
1839 call. They are obtained from Linux Kernel source. */
1840 arm_linux_record_tdep.size_pointer
1841 = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1842 arm_linux_record_tdep.size__old_kernel_stat = 32;
1843 arm_linux_record_tdep.size_tms = 16;
1844 arm_linux_record_tdep.size_loff_t = 8;
1845 arm_linux_record_tdep.size_flock = 16;
1846 arm_linux_record_tdep.size_oldold_utsname = 45;
1847 arm_linux_record_tdep.size_ustat = 20;
1848 arm_linux_record_tdep.size_old_sigaction = 16;
1849 arm_linux_record_tdep.size_old_sigset_t = 4;
1850 arm_linux_record_tdep.size_rlimit = 8;
1851 arm_linux_record_tdep.size_rusage = 72;
1852 arm_linux_record_tdep.size_timeval = 8;
1853 arm_linux_record_tdep.size_timezone = 8;
1854 arm_linux_record_tdep.size_old_gid_t = 2;
1855 arm_linux_record_tdep.size_old_uid_t = 2;
1856 arm_linux_record_tdep.size_fd_set = 128;
1857 arm_linux_record_tdep.size_old_dirent = 268;
1858 arm_linux_record_tdep.size_statfs = 64;
1859 arm_linux_record_tdep.size_statfs64 = 84;
1860 arm_linux_record_tdep.size_sockaddr = 16;
1861 arm_linux_record_tdep.size_int
1862 = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1863 arm_linux_record_tdep.size_long
1864 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1865 arm_linux_record_tdep.size_ulong
1866 = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1867 arm_linux_record_tdep.size_msghdr = 28;
1868 arm_linux_record_tdep.size_itimerval = 16;
1869 arm_linux_record_tdep.size_stat = 88;
1870 arm_linux_record_tdep.size_old_utsname = 325;
1871 arm_linux_record_tdep.size_sysinfo = 64;
1872 arm_linux_record_tdep.size_msqid_ds = 88;
1873 arm_linux_record_tdep.size_shmid_ds = 84;
1874 arm_linux_record_tdep.size_new_utsname = 390;
1875 arm_linux_record_tdep.size_timex = 128;
1876 arm_linux_record_tdep.size_mem_dqinfo = 24;
1877 arm_linux_record_tdep.size_if_dqblk = 68;
1878 arm_linux_record_tdep.size_fs_quota_stat = 68;
1879 arm_linux_record_tdep.size_timespec = 8;
1880 arm_linux_record_tdep.size_pollfd = 8;
1881 arm_linux_record_tdep.size_NFS_FHSIZE = 32;
1882 arm_linux_record_tdep.size_knfsd_fh = 132;
1883 arm_linux_record_tdep.size_TASK_COMM_LEN = 16;
1884 arm_linux_record_tdep.size_sigaction = 20;
1885 arm_linux_record_tdep.size_sigset_t = 8;
1886 arm_linux_record_tdep.size_siginfo_t = 128;
1887 arm_linux_record_tdep.size_cap_user_data_t = 12;
1888 arm_linux_record_tdep.size_stack_t = 12;
1889 arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long;
1890 arm_linux_record_tdep.size_stat64 = 96;
1891 arm_linux_record_tdep.size_gid_t = 4;
1892 arm_linux_record_tdep.size_uid_t = 4;
1893 arm_linux_record_tdep.size_PAGE_SIZE = 4096;
1894 arm_linux_record_tdep.size_flock64 = 24;
1895 arm_linux_record_tdep.size_user_desc = 16;
1896 arm_linux_record_tdep.size_io_event = 32;
1897 arm_linux_record_tdep.size_iocb = 64;
1898 arm_linux_record_tdep.size_epoll_event = 12;
1899 arm_linux_record_tdep.size_itimerspec
1900 = arm_linux_record_tdep.size_timespec * 2;
1901 arm_linux_record_tdep.size_mq_attr = 32;
1902 arm_linux_record_tdep.size_termios = 36;
1903 arm_linux_record_tdep.size_termios2 = 44;
1904 arm_linux_record_tdep.size_pid_t = 4;
1905 arm_linux_record_tdep.size_winsize = 8;
1906 arm_linux_record_tdep.size_serial_struct = 60;
1907 arm_linux_record_tdep.size_serial_icounter_struct = 80;
1908 arm_linux_record_tdep.size_hayes_esp_config = 12;
1909 arm_linux_record_tdep.size_size_t = 4;
1910 arm_linux_record_tdep.size_iovec = 8;
1911 arm_linux_record_tdep.size_time_t = 4;
1912
1913 /* These values are the second argument of system call "sys_ioctl".
1914 They are obtained from Linux Kernel source. */
1915 arm_linux_record_tdep.ioctl_TCGETS = 0x5401;
1916 arm_linux_record_tdep.ioctl_TCSETS = 0x5402;
1917 arm_linux_record_tdep.ioctl_TCSETSW = 0x5403;
1918 arm_linux_record_tdep.ioctl_TCSETSF = 0x5404;
1919 arm_linux_record_tdep.ioctl_TCGETA = 0x5405;
1920 arm_linux_record_tdep.ioctl_TCSETA = 0x5406;
1921 arm_linux_record_tdep.ioctl_TCSETAW = 0x5407;
1922 arm_linux_record_tdep.ioctl_TCSETAF = 0x5408;
1923 arm_linux_record_tdep.ioctl_TCSBRK = 0x5409;
1924 arm_linux_record_tdep.ioctl_TCXONC = 0x540a;
1925 arm_linux_record_tdep.ioctl_TCFLSH = 0x540b;
1926 arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
1927 arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
1928 arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
1929 arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
1930 arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
1931 arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
1932 arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
1933 arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
1934 arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
1935 arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
1936 arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
1937 arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
1938 arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
1939 arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
1940 arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
1941 arm_linux_record_tdep.ioctl_FIONREAD = 0x541b;
1942 arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD;
1943 arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
1944 arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
1945 arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
1946 arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
1947 arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
1948 arm_linux_record_tdep.ioctl_FIONBIO = 0x5421;
1949 arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
1950 arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
1951 arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
1952 arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
1953 arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
1954 arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
1955 arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
1956 arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
1957 arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1958 arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1959 arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
1960 arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1961 arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1962 arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1963 arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1964 arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1965 arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1966 arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1967 arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1968 arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1969 arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1970 arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1971 arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1972 arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1973 arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
1974 arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
1975 arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
1976 arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
1977 arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
1978 arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
1979 arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1980
1981 /* These values are the second argument of system call "sys_fcntl"
1982 and "sys_fcntl64". They are obtained from Linux Kernel source. */
1983 arm_linux_record_tdep.fcntl_F_GETLK = 5;
1984 arm_linux_record_tdep.fcntl_F_GETLK64 = 12;
1985 arm_linux_record_tdep.fcntl_F_SETLK64 = 13;
1986 arm_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1987
1988 arm_linux_record_tdep.arg1 = ARM_A1_REGNUM;
1989 arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 1;
1990 arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 2;
1991 arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3;
1992 arm_linux_record_tdep.arg5 = ARM_A1_REGNUM + 4;
1993 arm_linux_record_tdep.arg6 = ARM_A1_REGNUM + 5;
1994 arm_linux_record_tdep.arg7 = ARM_A1_REGNUM + 6;
1995 }
1996
1997 void
1998 _initialize_arm_linux_tdep (void)
1999 {
2000 gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
2001 arm_linux_init_abi);
2002 }
gdb_sys_pivot_root
Definition: linux-record.h:404
linux_record_tdep::ioctl_TIOCCONS
int ioctl_TIOCCONS
Definition: linux-record.h:124
gdbarch
Definition: gdbarch.c:127
gdb_sys_getgid16
Definition: linux-record.h:234
linux_record_tdep::ioctl_TIOCGICOUNT
int ioctl_TIOCGICOUNT
Definition: linux-record.h:156
arm_all_but_pc_registers_record
static int arm_all_but_pc_registers_record(struct regcache *regcache)
Definition: arm-linux-tdep.c:1642
gdb_sys_timer_settime
Definition: linux-record.h:447
gdb_sys_syslog
Definition: linux-record.h:290
gdb_sys_setfsuid16
Definition: linux-record.h:325
gdb_sys_mq_timedreceive
Definition: linux-record.h:467
gdb_sys_fgetxattr
Definition: linux-record.h:418
gdb_sys_utime
Definition: linux-record.h:217
gdb_sys_mq_open
Definition: linux-record.h:464
linux_record_tdep::ioctl_TCSETAF
int ioctl_TCSETAF
Definition: linux-record.h:102
arm-get-next-pcs.h
linux_record_tdep::ioctl_TIOCTTYGSTRUCT
int ioctl_TIOCTTYGSTRUCT
Definition: linux-record.h:133
arm_linux_sigreturn_tramp_frame
static struct tramp_frame arm_linux_sigreturn_tramp_frame
Definition: arm-linux-tdep.c:384
linux_record_tdep::arg1
int arg1
Definition: linux-record.h:170
gdb_sys_rt_sigqueueinfo
Definition: linux-record.h:365
gdb_sys_dup2
Definition: linux-record.h:250
gdb_sys_time
Definition: linux-record.h:200
gdb_sys_shutdown
Definition: linux-record.h:520
arm_stap_parse_special_token
static int arm_stap_parse_special_token(struct gdbarch *gdbarch, struct stap_parse_info *p)
Definition: arm-linux-tdep.c:1162
gdb_sys_lchown16
Definition: linux-record.h:203
regcache_raw_get_unsigned
ULONGEST regcache_raw_get_unsigned(struct regcache *regcache, int regnum)
Definition: common-regcache.c:26
ARM_OABI_SYSCALL_RESTART_SYSCALL
#define ARM_OABI_SYSCALL_RESTART_SYSCALL
Definition: arm-linux-tdep.c:257
linux_record_tdep::ioctl_TIOCSBRK
int ioctl_TIOCSBRK
Definition: linux-record.h:134
linux_record_tdep::size_itimerspec
int size_itimerspec
Definition: linux-record.h:81
trad_frame_set_reg_addr
void trad_frame_set_reg_addr(struct trad_frame_cache *this_trad_cache, int regnum, CORE_ADDR addr)
Definition: trad-frame.c:126
linux_record_tdep::ioctl_TCFLSH
int ioctl_TCFLSH
Definition: linux-record.h:105
linux_record_tdep::size_serial_icounter_struct
int size_serial_icounter_struct
Definition: linux-record.h:88
arm_linux_copy_svc
static int arm_linux_copy_svc(struct gdbarch *gdbarch, struct regcache *regs, arm_displaced_step_closure *dsc)
Definition: arm-linux-tdep.c:980
gdb_sys_epoll_create
Definition: linux-record.h:441
frame_id_build
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:624
gdb_sys_swapoff
Definition: linux-record.h:302
gdb_sys_getpgrp
Definition: linux-record.h:252
gdb_sys_move_pages
Definition: linux-record.h:504
linux_record_tdep::ioctl_TIOCSWINSZ
int ioctl_TIOCSWINSZ
Definition: linux-record.h:114
gdb_sys_splice
Definition: linux-record.h:500
gdb_sys_mq_unlink
Definition: linux-record.h:465
gdb_sys_pselect6
Definition: linux-record.h:495
ARM_SIGCONTEXT_R0
#define ARM_SIGCONTEXT_R0
Definition: arm-linux.h:54
gdb_sys_rename
Definition: linux-record.h:225
gdb_sys_fsetxattr
Definition: linux-record.h:415
ARM_LINUX_JB_ELEMENT_SIZE
#define ARM_LINUX_JB_ELEMENT_SIZE
Definition: arm-linux-tdep.c:106
arm_linux_supply_nwfpe
void arm_linux_supply_nwfpe(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs_buf, size_t len)
Definition: arm-linux-tdep.c:622
linux_record_tdep::size_cap_user_data_t
int size_cap_user_data_t
Definition: linux-record.h:69
linux_record_tdep::ioctl_TIOCSCTTY
int ioctl_TIOCSCTTY
Definition: linux-record.h:108
gdb_sys_getsockname
Definition: linux-record.h:523
arm_linux_get_next_pcs_syscall_next_pc
static CORE_ADDR arm_linux_get_next_pcs_syscall_next_pc(struct arm_get_next_pcs *self)
Definition: arm-linux-tdep.c:871
linux_record_tdep::fcntl_F_GETLK64
int fcntl_F_GETLK64
Definition: linux-record.h:164
arm_eabi_linux_sigreturn_tramp_frame
static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame
Definition: arm-linux-tdep.c:404
set_gdbarch_displaced_step_fixup
void set_gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
Definition: gdbarch.c:3982
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
ARM_F7_REGNUM
Definition: arm.h:34
gdb_sys_clock_gettime
Definition: linux-record.h:452
gdb_sys_sched_getparam
Definition: linux-record.h:342
gdbarch_tdep::thumb_breakpoint
const gdb_byte * thumb_breakpoint
Definition: arm-tdep.h:121
gdb_sys_adjtimex
Definition: linux-record.h:311
gdb_sys_readlink
Definition: linux-record.h:272
get_current_frame
struct frame_info * get_current_frame(void)
Definition: frame.c:1563
stap_parse_info::arg_type
struct type * arg_type
Definition: stap-probe.h:60
syscall
Definition: target.h:105
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
gdb_sys_fstat
Definition: linux-record.h:215
set_gdbarch_fetch_tls_load_module_address
void set_gdbarch_fetch_tls_load_module_address(struct gdbarch *gdbarch, gdbarch_fetch_tls_load_module_address_ftype fetch_tls_load_module_address)
Definition: gdbarch.c:3038
ARM_D0_REGNUM
Definition: arm.h:46
gdb_sys_add_key
Definition: linux-record.h:473
TRAMP_SENTINEL_INSN
#define TRAMP_SENTINEL_INSN
Definition: tramp-frame.h:44
gdb_sys_mbind
Definition: linux-record.h:461
THUMB2_EABI_SYSCALL
#define THUMB2_EABI_SYSCALL
Definition: arm-linux-tdep.c:253
insert_breakpoints
void insert_breakpoints(void)
Definition: breakpoint.c:2845
linux_record_tdep::ioctl_TCSETSW
int ioctl_TCSETSW
Definition: linux-record.h:97
gdb_sys_setuid16
Definition: linux-record.h:210
linux_record_tdep::ioctl_TIOCSHAYESESP
int ioctl_TIOCSHAYESESP
Definition: linux-record.h:158
arm_linux_sigreturn_next_pc_offset
int arm_linux_sigreturn_next_pc_offset(unsigned long sp, unsigned long sp_data, unsigned long svc_number, int is_sigreturn)
Definition: arm-linux.c:29
linux_record_tdep::size_msqid_ds
int size_msqid_ds
Definition: linux-record.h:54
linux_record_tdep::ioctl_TIOCCBRK
int ioctl_TIOCCBRK
Definition: linux-record.h:135
get_thread_regcache
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:434
stap-probe.h
linux_record_tdep::ioctl_TCSETS2
int ioctl_TCSETS2
Definition: linux-record.h:138
gdb_sys_rt_sigpending
Definition: linux-record.h:363
stoken::ptr
const char * ptr
Definition: parser-defs.h:91
set_gdbarch_stap_parse_special_token
void set_gdbarch_stap_parse_special_token(struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype stap_parse_special_token)
Definition: gdbarch.c:4499
gdb_sys_fstatat64
Definition: linux-record.h:487
linux_record_tdep::size_flock64
int size_flock64
Definition: linux-record.h:76
gdb_old_mmap
Definition: linux-record.h:277
gdb_sys_lremovexattr
Definition: linux-record.h:423
gdb_sys_symlinkat
Definition: linux-record.h:491
gdb_sys_setsid
Definition: linux-record.h:253
gdb_sys_setresgid
Definition: linux-record.h:397
THUMB2_SET_R7_SIGRETURN2
#define THUMB2_SET_R7_SIGRETURN2
Definition: arm-linux-tdep.c:250
gdb_sys_fstatfs64
Definition: linux-record.h:456
ARM_NEW_SIGFRAME_MAGIC
#define ARM_NEW_SIGFRAME_MAGIC
Definition: arm-linux.h:69
gdb_sys_nice
Definition: linux-record.h:221
linux_record_tdep::ioctl_TIOCSERGSTRUCT
int ioctl_TIOCSERGSTRUCT
Definition: linux-record.h:151
record-full.h
get_prev_frame
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2254
record_full_arch_list_add_reg
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
Definition: record-full.c:468
arm_linux_supply_vfp
static void arm_linux_supply_vfp(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs_buf, size_t len)
Definition: arm-linux-tdep.c:660
linux_record_tdep::size_gid_t
int size_gid_t
Definition: linux-record.h:73
linux_record_tdep::ioctl_FIOCLEX
int ioctl_FIOCLEX
Definition: linux-record.h:144
write_memory_unsigned_integer
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
Definition: corefile.c:417
frame_unwind_caller_pc
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
Definition: frame.c:944
gdbarch_int_bit
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1579
func
void(* func)(char *)
Definition: remote-fileio.c:1104
tdesc_arm_with_vfpv2
struct target_desc * tdesc_arm_with_vfpv2
Definition: arm-with-vfpv2.c:8
iterate_over_regset_sections_cb
void() iterate_over_regset_sections_cb(const char *sect_name, int size, const struct regset *regset, const char *human_name, void *cb_data)
Definition: gdbarch.h:99
set_gdbarch_skip_trampoline_code
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3316
glibc_skip_solib_resolver
CORE_ADDR glibc_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: glibc-tdep.c:38
linux_record_tdep::ioctl_TCGETA
int ioctl_TCGETA
Definition: linux-record.h:99
NWFPE_FPSR_OFFSET
#define NWFPE_FPSR_OFFSET
Definition: arm-linux-tdep.h:35
arm_linux_restart_syscall_tramp_frame
static struct tramp_frame arm_linux_restart_syscall_tramp_frame
Definition: arm-linux-tdep.c:450
gdb_sys_lsetxattr
Definition: linux-record.h:414
set_gdbarch_displaced_step_location
void set_gdbarch_displaced_step_location(struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype displaced_step_location)
Definition: gdbarch.c:3999
bp_step_resume
Definition: breakpoint.h:97
linux_record_tdep::size_time_t
int size_time_t
Definition: linux-record.h:92
gdbarch_ptr_bit
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1831
collect_nwfpe_register
void collect_nwfpe_register(const struct regcache *regcache, int regno, gdb_byte *regs)
Definition: arm-linux-tdep.c:585
trad_frame_set_id
void trad_frame_set_id(struct trad_frame_cache *this_trad_cache, struct frame_id this_id)
Definition: trad-frame.c:171
arm_psr_thumb_bit
int arm_psr_thumb_bit(struct gdbarch *gdbarch)
Definition: arm-tdep.c:286
gdb_sys_sched_setscheduler
Definition: linux-record.h:343
gdb_sys_timer_delete
Definition: linux-record.h:450
linux_record_tdep::size_statfs
int size_statfs
Definition: linux-record.h:43
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
GDB_OSABI_LINUX
Definition: defs.h:517
gdb_sys_unlinkat
Definition: linux-record.h:488
gdb_sys_nanosleep
Definition: linux-record.h:349
linux_record_tdep::ioctl_TIOCSERCONFIG
int ioctl_TIOCSERCONFIG
Definition: linux-record.h:146
set_gdbarch_stap_register_prefixes
void set_gdbarch_stap_register_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_prefixes)
Definition: gdbarch.c:4366
gdb_sys_get_robust_list
Definition: linux-record.h:499
linux_record_tdep::ioctl_TIOCSERGETMULTI
int ioctl_TIOCSERGETMULTI
Definition: linux-record.h:153
frame_unwind_register_unsigned
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1279
linux_record_tdep::size_iovec
int size_iovec
Definition: linux-record.h:91
stap_parse_info
Definition: stap-probe.h:29
gdbarch_tdep::fp_model
enum arm_float_model fp_model
Definition: arm-tdep.h:101
gdb_sys_statfs
Definition: linux-record.h:286
gdb_sys_epoll_wait
Definition: linux-record.h:443
displaced_read_reg
ULONGEST displaced_read_reg(struct regcache *regs, arm_displaced_step_closure *dsc, int regno)
Definition: arm-tdep.c:4417
arm-linux-tdep.h
linux_record_tdep::ioctl_TIOCSLCKTRMIOS
int ioctl_TIOCSLCKTRMIOS
Definition: linux-record.h:150
memset
void * memset(T *s, int c, size_t n)=delete
gdb_sys_getitimer
Definition: linux-record.h:292
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
gdb_sys_getdents
Definition: linux-record.h:328
inferior_thread
struct thread_info * inferior_thread(void)
Definition: thread.c:90
target_can_do_single_step
#define target_can_do_single_step()
Definition: target.h:1930
gdb_sys_pipe
Definition: linux-record.h:229
gdb_sys_getresuid16
Definition: linux-record.h:352
gdb_sys_access
Definition: linux-record.h:220
gdbarch_tdep
Definition: aarch64-tdep.h:55
stap_parse_info::arg
const char * arg
Definition: stap-probe.h:46
linux_record_tdep::fcntl_F_GETLK
int fcntl_F_GETLK
Definition: linux-record.h:163
gdb_sys_openat
Definition: linux-record.h:482
gdb_sys_io_setup
Definition: linux-record.h:432
gdb_sys_capset
Definition: linux-record.h:372
gdb_sys_madvise
Definition: linux-record.h:406
linux_record_tdep::ioctl_TIOCMBIC
int ioctl_TIOCMBIC
Definition: linux-record.h:117
gdb_sys_listen
Definition: linux-record.h:522
ARM_LINUX_JB_PC_FPA
#define ARM_LINUX_JB_PC_FPA
Definition: arm-linux-tdep.c:107
gdb_sys_lgetxattr
Definition: linux-record.h:417
linux_init_abi
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: linux-tdep.c:2492
linux_record_tdep::size_termios
int size_termios
Definition: linux-record.h:83
gdb_sys_fchownat
Definition: linux-record.h:485
THUMB2_SET_R7_SIGRETURN1
#define THUMB2_SET_R7_SIGRETURN1
Definition: arm-linux-tdep.c:249
eabi_linux_arm_be_breakpoint
static const gdb_byte eabi_linux_arm_be_breakpoint[]
Definition: arm-linux-tdep.c:78
tdesc_arm_with_neon
struct target_desc * tdesc_arm_with_neon
Definition: arm-with-neon.c:8
gdb_sys_readlinkat
Definition: linux-record.h:492
gdb_sys_rt_sigtimedwait
Definition: linux-record.h:364
auxv.h
linux_record_tdep::size_epoll_event
int size_epoll_event
Definition: linux-record.h:80
gdb_sys_setfsgid16
Definition: linux-record.h:326
arm_displaced_init_closure
void arm_displaced_init_closure(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, arm_displaced_step_closure *dsc)
Definition: arm-tdep.c:7616
gdb_sys_sched_setaffinity
Definition: linux-record.h:428
SIGTRAMP_FRAME
Definition: frame.h:255
linux_record_tdep::size_TASK_COMM_LEN
int size_TASK_COMM_LEN
Definition: linux-record.h:65
linux_record_tdep::size_size_t
int size_size_t
Definition: linux-record.h:90
gdbarch_tdep::arm_breakpoint
const gdb_byte * arm_breakpoint
Definition: arm-tdep.h:119
linux_record_tdep::size_ulong
int size_ulong
Definition: linux-record.h:48
frame_info
Definition: frame.c:85
gdb_sys_readv
Definition: linux-record.h:332
gdbarch_long_bit
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1596
svr4_ilp32_fetch_link_map_offsets
struct link_map_offsets * svr4_ilp32_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3183
gdb_sys_sethostname
Definition: linux-record.h:261
gdb_sys_fsync
Definition: linux-record.h:305
gdb_sys_getgroups16
Definition: linux-record.h:267
linux_record_tdep::size_sockaddr
int size_sockaddr
Definition: linux-record.h:45
thumb2_eabi_linux_sigreturn_tramp_frame
static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame
Definition: arm-linux-tdep.c:426
linux_record_tdep::ioctl_TIOCSPGRP
int ioctl_TIOCSPGRP
Definition: linux-record.h:110
gdb_sys_getdents64
Definition: linux-record.h:407
gdbarch_tdep::lowest_pc
CORE_ADDR lowest_pc
Definition: aarch64-tdep.h:58
gdb_sys_kexec_load
Definition: linux-record.h:470
arm_displaced_step_closure::insn_size
unsigned int insn_size
Definition: arm-tdep.h:209
arm_displaced_step_closure::scratch_base
CORE_ADDR scratch_base
Definition: arm-tdep.h:221
gdb_old_readdir
Definition: linux-record.h:276
symtab_and_line::section
struct obj_section * section
Definition: symtab.h:1753
gdb_sys_recvmsg
Definition: linux-record.h:519
gdb_sys_ftruncate64
Definition: linux-record.h:381
gdb_sys_gettimeofday
Definition: linux-record.h:265
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
gdb_sys_execve
Definition: linux-record.h:198
arm_get_next_pcs
std::vector< CORE_ADDR > arm_get_next_pcs(struct arm_get_next_pcs *self)
Definition: arm-get-next-pcs.c:911
gdb_sys_ptrace
Definition: linux-record.h:213
_
#define _(String)
Definition: gdb_locale.h:35
linux_record_tdep::arg2
int arg2
Definition: linux-record.h:171
get_frame_memory_unsigned
ULONGEST get_frame_memory_unsigned(struct frame_info *this_frame, CORE_ADDR addr, int len)
Definition: frame.c:2671
linux_record_tdep::size_old_dirent
int size_old_dirent
Definition: linux-record.h:42
gdb_sys_semctl
Definition: linux-record.h:534
gdb_sys_getpgid
Definition: linux-record.h:319
gdb_sys_rt_sigaction
Definition: linux-record.h:361
gdb_sys_clock_settime
Definition: linux-record.h:451
gdb_sys_mq_timedsend
Definition: linux-record.h:466
linux_record_tdep::size_oldold_utsname
int size_oldold_utsname
Definition: linux-record.h:31
defs.h
builtin_type
Definition: gdbtypes.h:1495
gdb_sys_swapon
Definition: linux-record.h:274
gdb_sys_setregid16
Definition: linux-record.h:258
gdbarch_tdep
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1491
gdb_sys_pread64
Definition: linux-record.h:367
gdb_sys_oldumount
Definition: linux-record.h:209
arm_linux_sigtramp_cache
static void arm_linux_sigtramp_cache(struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func, int regs_offset)
Definition: arm-linux-tdep.c:279
linux_record_tdep::size_pollfd
int size_pollfd
Definition: linux-record.h:62
gdb_sys_recvfrom
Definition: linux-record.h:517
linux_record_tdep::arg3
int arg3
Definition: linux-record.h:172
linux_record_tdep::ioctl_TCGETS2
int ioctl_TCGETS2
Definition: linux-record.h:137
displaced_write_reg
void displaced_write_reg(struct regcache *regs, arm_displaced_step_closure *dsc, int regno, ULONGEST val, enum pc_write_style write_pc)
Definition: arm-tdep.c:4537
set_gdbarch_process_record
void set_gdbarch_process_record(struct gdbarch *gdbarch, gdbarch_process_record_ftype process_record)
Definition: gdbarch.c:4137
gdb_sys_shmdt
Definition: linux-record.h:535
gdb_sys_set_tid_address
Definition: linux-record.h:445
gdb_sys_setfsgid
Definition: linux-record.h:403
gdb_sys_mknod
Definition: linux-record.h:201
gdb_sys_setitimer
Definition: linux-record.h:291
gdb_sys_faccessat
Definition: linux-record.h:494
displaced_step_closure
Definition: infrun.h:249
linux_record_tdep::arg7
int arg7
Definition: linux-record.h:176
set_gdbarch_stap_register_indirection_suffixes
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
Definition: gdbarch.c:4417
gdbarch_tdep::arm_abi
enum arm_abi_kind arm_abi
Definition: arm-tdep.h:99
eabi_linux_arm_le_breakpoint
static const gdb_byte eabi_linux_arm_le_breakpoint[]
Definition: arm-linux-tdep.c:76
frame_unwind_arch
struct gdbarch * frame_unwind_arch(struct frame_info *next_frame)
Definition: frame.c:2697
arch-utils.h
find_pc_overlay
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3173
gdb_sys_rt_sigsuspend
Definition: linux-record.h:366
linux_record_tdep::ioctl_TIOCGWINSZ
int ioctl_TIOCGWINSZ
Definition: linux-record.h:113
svr4_fetch_objfile_link_map
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-svr4.c:1579
linux_record_tdep::arg4
int arg4
Definition: linux-record.h:173
cleanup_kernel_helper_return
static void cleanup_kernel_helper_return(struct gdbarch *gdbarch, struct regcache *regs, arm_displaced_step_closure *dsc)
Definition: arm-linux-tdep.c:1070
linux_record_tdep::size_uid_t
int size_uid_t
Definition: linux-record.h:74
gdb_sys_open
Definition: linux-record.h:192
gdb_sys_setresuid
Definition: linux-record.h:395
gdb_sys_socketcall
Definition: linux-record.h:289
gdb_sys_mknodat
Definition: linux-record.h:484
ARM_OLD_RT_SIGFRAME_UCONTEXT
#define ARM_OLD_RT_SIGFRAME_UCONTEXT
Definition: arm-linux.h:65
gdb_sys_readahead
Definition: linux-record.h:412
regset
Definition: regset.h:34
gdb_sys_sigpending
Definition: linux-record.h:260
gdb_sys_shmget
Definition: linux-record.h:529
linux_record_tdep::ioctl_TIOCSPTLCK
int ioctl_TIOCSPTLCK
Definition: linux-record.h:142
parser-defs.h
gdb_sys_pipe2
Definition: linux-record.h:511
arm_displaced_step_closure::svc
struct arm_displaced_step_closure::@5::@10 svc
typeExtended
#define typeExtended
Definition: arm-linux-tdep.c:547
gdb_sys_keyctl
Definition: linux-record.h:475
gdb_sys_set_robust_list
Definition: linux-record.h:498
gdb_sys_ppoll
Definition: linux-record.h:496
gdb_sys_tee
Definition: linux-record.h:502
gdb_sys_vfork
Definition: linux-record.h:377
gdb_sys_setpriority
Definition: linux-record.h:284
gdb_sys_getsid
Definition: linux-record.h:334
set_gdbarch_stap_integer_prefixes
void set_gdbarch_stap_integer_prefixes(struct gdbarch *gdbarch, const char *const *stap_integer_prefixes)
Definition: gdbarch.c:4332
gdb_sys_semget
Definition: linux-record.h:532
gdb_sys_request_key
Definition: linux-record.h:474
set_gdbarch_stap_gdb_register_prefix
void set_gdbarch_stap_gdb_register_prefix(struct gdbarch *gdbarch, const char *stap_gdb_register_prefix)
Definition: gdbarch.c:4434
stap_parse_info::pstate
struct parser_state pstate
Definition: stap-probe.h:49
linux_record_tdep::ioctl_TIOCLINUX
int ioctl_TIOCLINUX
Definition: linux-record.h:123
ARM_LINUX_JB_PC_EABI
#define ARM_LINUX_JB_PC_EABI
Definition: arm-linux-tdep.c:108
linux_record_tdep::ioctl_TIOCSERSETMULTI
int ioctl_TIOCSERSETMULTI
Definition: linux-record.h:154
linux_record_tdep::size_timespec
int size_timespec
Definition: linux-record.h:61
gdb_sys_exit
Definition: linux-record.h:188
arm_get_next_pcs_ops
Definition: arm-get-next-pcs.h:29
gdbarch_tdep::have_fpa_registers
int have_fpa_registers
Definition: arm-tdep.h:103
gdb_sys_truncate64
Definition: linux-record.h:380
gdb_sys_lookup_dcookie
Definition: linux-record.h:440
ARM_LINUX_SIZEOF_VFP
#define ARM_LINUX_SIZEOF_VFP
Definition: arm-linux-tdep.c:657
write_exp_elt_longcst
void write_exp_elt_longcst(struct parser_state *ps, LONGEST expelt)
Definition: parse.c:255
get_frame_type
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2619
gdb_sys_fdatasync
Definition: linux-record.h:335
linux_record_tdep::size_loff_t
int size_loff_t
Definition: linux-record.h:29
arm_process_record
int arm_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR insn_addr)
Definition: arm-tdep.c:13176
gdb_sys_umask
Definition: linux-record.h:247
get_frame_id
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:520
linux_record_tdep::size_old_sigaction
int size_old_sigaction
Definition: linux-record.h:33
arm_linux_get_next_pcs_ops
static struct arm_get_next_pcs_ops arm_linux_get_next_pcs_ops
Definition: arm-linux-tdep.c:270
linux_record_tdep::size_sysinfo
int size_sysinfo
Definition: linux-record.h:53
NORMAL_FRAME
Definition: frame.h:244
gdb_sys_fchmod
Definition: linux-record.h:281
gdb_sys_tgkill
Definition: linux-record.h:457
arm_linux_sigreturn_next_pc
static CORE_ADDR arm_linux_sigreturn_next_pc(struct regcache *regcache, unsigned long svc_number, int *is_thumb)
Definition: arm-linux-tdep.c:787
gdb_sys_sigreturn
Definition: linux-record.h:306
gdb_sys_gettid
Definition: linux-record.h:411
linux_record_tdep::ioctl_TIOCEXCL
int ioctl_TIOCEXCL
Definition: linux-record.h:106
gdb_sys_flistxattr
Definition: linux-record.h:421
gdb_sys_sendfile64
Definition: linux-record.h:426
gdb_sys_mlockall
Definition: linux-record.h:339
gdb_sys_socket
Definition: linux-record.h:513
gdbarch_tdep::thumb_breakpoint_size
int thumb_breakpoint_size
Definition: arm-tdep.h:122
arm_linux_rt_sigreturn_tramp_frame
static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame
Definition: arm-linux-tdep.c:394
gdb_sys_setreuid
Definition: linux-record.h:390
gdb_sys_setxattr
Definition: linux-record.h:413
gdb_sys_getrusage
Definition: linux-record.h:264
gdb_sys_pause
Definition: linux-record.h:216
linux_record_tdep::ioctl_TCSETA
int ioctl_TCSETA
Definition: linux-record.h:100
arm_displaced_step_closure::wrote_to_pc
int wrote_to_pc
Definition: arm-tdep.h:161
gdb_sys_io_getevents
Definition: linux-record.h:434
linux_record_tdep::size_knfsd_fh
int size_knfsd_fh
Definition: linux-record.h:64
arm-tdep.h
linux_record_tdep::size_shmid_ds
int size_shmid_ds
Definition: linux-record.h:55
gdbarch_addr_bits_remove
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:3208
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
linux_record_tdep::ioctl_FIONBIO
int ioctl_FIONBIO
Definition: linux-record.h:128
trad-frame.h
linux_record_tdep::ioctl_TIOCSSOFTCAR
int ioctl_TIOCSSOFTCAR
Definition: linux-record.h:120
target_ops
Definition: target.h:412
gdb_sys_quotactl
Definition: linux-record.h:318
gdb_sys_ioprio_set
Definition: linux-record.h:476
gdb_sys_stat
Definition: linux-record.h:205
record_linux_system_call
int record_linux_system_call(enum gdb_syscall syscall, struct regcache *regcache, struct linux_record_tdep *tdep)
Definition: linux-record.c:241
find_solib_trampoline_target
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
Definition: minsyms.c:1492
solib-svr4.h
linux_record_tdep::size_user_desc
int size_user_desc
Definition: linux-record.h:77
gdb_sys_read
Definition: linux-record.h:190
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
regcache_cooked_read_unsigned
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:777
gdb_sys_brk
Definition: linux-record.h:232
linux_record_tdep::ioctl_TIOCGPGRP
int ioctl_TIOCGPGRP
Definition: linux-record.h:109
gdb_sys_unshare
Definition: linux-record.h:497
osabi.h
gdb_sys_getppid
Definition: linux-record.h:251
linux_record_tdep::size_pointer
int size_pointer
Definition: linux-record.h:26
arm_linux_collect_vfp
static void arm_linux_collect_vfp(const struct regset *regset, const struct regcache *regcache, int regnum, void *regs_buf, size_t len)
Definition: arm-linux-tdep.c:677
gdb_sys_getuid16
Definition: linux-record.h:211
arm_linux_get_next_pcs_fixup
CORE_ADDR arm_linux_get_next_pcs_fixup(struct arm_get_next_pcs *self, CORE_ADDR nextpc)
Definition: arm-linux.c:65
trad_frame_cache
Definition: trad-frame.c:27
regcache.h
gdb_sys_sigprocmask
Definition: linux-record.h:313
arm_apcs_32
int arm_apcs_32
Definition: arm-tdep.c:281
arm_linux_thumb2_be_breakpoint
static const gdb_byte arm_linux_thumb2_be_breakpoint[]
Definition: arm-linux-tdep.c:91
gdb_sys_sendto
Definition: linux-record.h:516
gdb_sys_recv
Definition: linux-record.h:528
debug_displaced
int debug_displaced
Definition: infrun.c:156
arm_linux_collect_gregset
void arm_linux_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs_buf, size_t len)
Definition: arm-linux-tdep.c:515
gdb_sys_eventfd2
Definition: linux-record.h:508
linux_record_tdep::size_timex
int size_timex
Definition: linux-record.h:57
ptid_t
Definition: ptid.h:35
gdb_sys_getcwd
Definition: linux-record.h:370
fprintf_unfiltered
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2018
linux_record_tdep::size_sigset_t
int size_sigset_t
Definition: linux-record.h:67
linux_record_tdep::size_old_gid_t
int size_old_gid_t
Definition: linux-record.h:39
arm_linux_vfpregset
static const struct regset arm_linux_vfpregset
Definition: arm-linux-tdep.c:703
target_auxv_search
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
Definition: auxv.c:375
linux_record_tdep::size_pid_t
int size_pid_t
Definition: linux-record.h:85
gdb_sys_setuid
Definition: linux-record.h:400
gdb_sys_mq_getsetattr
Definition: linux-record.h:469
gdb_sys_no_syscall
Definition: linux-record.h:185
cli-utils.h
gdb_sys_getrlimit
Definition: linux-record.h:378
frame.h
linux_record_tdep::size_rlimit
int size_rlimit
Definition: linux-record.h:35
linux_record_tdep::ioctl_TIOCSERSWILD
int ioctl_TIOCSERSWILD
Definition: linux-record.h:148
gdb_sys_inotify_init1
Definition: linux-record.h:512
FP_REGISTER_SIZE
#define FP_REGISTER_SIZE
Definition: arm-tdep.h:38
gdb_sys_getuid
Definition: linux-record.h:386
NWFPE_TAGS_OFFSET
#define NWFPE_TAGS_OFFSET
Definition: arm-linux-tdep.h:37
gdb_sys_timer_getoverrun
Definition: linux-record.h:449
arm-linux.h
arm_linux_restart_syscall_init
static void arm_linux_restart_syscall_init(const struct tramp_frame *self, struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
Definition: arm-linux-tdep.c:344
THUMB2_SET_R7_RT_SIGRETURN2
#define THUMB2_SET_R7_RT_SIGRETURN2
Definition: arm-linux-tdep.c:252
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
gdbthread.h
gdb_sys_sysfs
Definition: linux-record.h:322
gdb_sys_getpriority
Definition: linux-record.h:283
inferior.h
gdb_sys_getegid16
Definition: linux-record.h:237
linux_record_tdep::size_winsize
int size_winsize
Definition: linux-record.h:86
gdb_sys_munmap
Definition: linux-record.h:278
gdbarch_tdep::jb_pc
int jb_pc
Definition: aarch64-tdep.h:62
linux_record_tdep::size_termios2
int size_termios2
Definition: linux-record.h:84
arm_displaced_step_fixup
void arm_displaced_step_fixup(struct gdbarch *gdbarch, struct displaced_step_closure *dsc_, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
Definition: arm-tdep.c:7673
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
gdb_sys_sigsuspend
Definition: linux-record.h:259
set_solib_svr4_fetch_link_map_offsets
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
Definition: solib-svr4.c:3137
set_gdbarch_stap_register_indirection_prefixes
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
Definition: gdbarch.c:4400
BRANCH_WRITE_PC
Definition: arm-tdep.h:232
infrun.h
gdb_sys_clock_getres
Definition: linux-record.h:453
linux_record_tdep::arg5
int arg5
Definition: linux-record.h:174
gdb_sys_getpid
Definition: linux-record.h:207
gdb_sys_sched_setparam
Definition: linux-record.h:341
HWCAP_VFPv3D16
#define HWCAP_VFPv3D16
Definition: arm-linux-tdep.h:65
gdb_sys_shmctl
Definition: linux-record.h:531
linux_record_tdep::size_ustat
int size_ustat
Definition: linux-record.h:32
gdb_sys_socketpair
Definition: linux-record.h:525
gdb_sys_setfsuid
Definition: linux-record.h:402
arm_is_thumb
int arm_is_thumb(struct regcache *regcache)
Definition: arm-tdep.c:297
arm_linux_thumb2_le_breakpoint
static const gdb_byte arm_linux_thumb2_le_breakpoint[]
Definition: arm-linux-tdep.c:93
arm_linux_record_tdep
struct linux_record_tdep arm_linux_record_tdep
Definition: arm-linux-tdep.c:1263
ARM_SIGRETURN
#define ARM_SIGRETURN
Definition: arm-linux-tdep.c:262
linux_record_tdep::size_flock
int size_flock
Definition: linux-record.h:30
linux_record_tdep::ioctl_TCXONC
int ioctl_TCXONC
Definition: linux-record.h:104
stap_parse_info::saved_arg
const char * saved_arg
Definition: stap-probe.h:54
linux_record_tdep::ioctl_TIOCGPTN
int ioctl_TIOCGPTN
Definition: linux-record.h:141
gdb_sys_setpgid
Definition: linux-record.h:244
gdb_sys_sigaltstack
Definition: linux-record.h:373
gdb_sys_semop
Definition: linux-record.h:533
ARM_LDR_PC_SP_12
#define ARM_LDR_PC_SP_12
Definition: arm-linux-tdep.c:258
gdb_sys_sigaction
Definition: linux-record.h:254
linux_record_tdep::ioctl_TCSETSF2
int ioctl_TCSETSF2
Definition: linux-record.h:140
ARM_FLOAT_SOFT_VFP
Definition: arm-tdep.h:72
ARM_FLOAT_SOFT_FPA
Definition: arm-tdep.h:70
gdb_sys_inotify_rm_watch
Definition: linux-record.h:480
gdb_sys_bind
Definition: linux-record.h:521
gdb_sys_fchown16
Definition: linux-record.h:282
gdb_sys_setdomainname
Definition: linux-record.h:308
gdb_sys_epoll_create1
Definition: linux-record.h:509
thumb2_eabi_linux_rt_sigreturn_tramp_frame
static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame
Definition: arm-linux-tdep.c:438
gdb_sys_chdir
Definition: linux-record.h:199
HWCAP_NEON
#define HWCAP_NEON
Definition: arm-fbsd-tdep.h:35
gdb_sys_setrlimit
Definition: linux-record.h:262
linux_record_tdep::ioctl_FIOASYNC
int ioctl_FIOASYNC
Definition: linux-record.h:145
typeSingle
#define typeSingle
Definition: arm-linux-tdep.c:545
trad_frame_set_reg_value
void trad_frame_set_reg_value(struct trad_frame_cache *this_trad_cache, int regnum, LONGEST val)
Definition: trad-frame.c:109
ARM_D31_REGNUM
Definition: arm.h:47
gdb_sys_sched_yield
Definition: linux-record.h:345
ARM_A1_REGNUM
Definition: arm.h:25
ARM_FPSCR_REGNUM
Definition: arm.h:48
gdb_sys_init_module
Definition: linux-record.h:315
breakpoint.h
arm_process_displaced_insn
void arm_process_displaced_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs, arm_displaced_step_closure *dsc)
Definition: arm-tdep.c:7556
gdb_sys_kill
Definition: linux-record.h:224
arm_get_next_pcs
Definition: arm-get-next-pcs.h:41
regnum
int regnum
Definition: aarch64-tdep.c:77
set_xml_syscall_file_name
void set_xml_syscall_file_name(struct gdbarch *gdbarch, const char *name)
Definition: xml-syscall.c:513
printf_unfiltered
void printf_unfiltered(const char *format,...)
Definition: utils.c:2056
ARM_LR_REGNUM
Definition: arm.h:30
gdb_sys_msgsnd
Definition: linux-record.h:537
arm_linux_software_single_step
static std::vector< CORE_ADDR > arm_linux_software_single_step(struct regcache *regcache)
Definition: arm-linux-tdep.c:923
gdb_sys_io_destroy
Definition: linux-record.h:433
arm_get_next_pcs_addr_bits_remove
CORE_ADDR arm_get_next_pcs_addr_bits_remove(struct arm_get_next_pcs *self, CORE_ADDR val)
Definition: arm-tdep.c:6223
ARM_OLD_RT_SIGFRAME_SIGINFO
#define ARM_OLD_RT_SIGFRAME_SIGINFO
Definition: arm-linux.h:64
xml-syscall.h
gdb_sys_mq_notify
Definition: linux-record.h:468
linux_record_tdep::size_statfs64
int size_statfs64
Definition: linux-record.h:44
user_reg_map_name_to_regnum
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:130
linux_record_tdep
Definition: linux-record.h:23
gdb_sys_prctl
Definition: linux-record.h:359
get_frame_register_unsigned
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1308
gdb_sys_creat
Definition: linux-record.h:195
gdb_sys_sysinfo
Definition: linux-record.h:303
gdbarch_register_osabi
void gdbarch_register_osabi(enum bfd_architecture arch, unsigned long machine, enum gdb_osabi osabi, void(*init_osabi)(struct gdbarch_info, struct gdbarch *))
Definition: osabi.c:143
linux_displaced_step_location
CORE_ADDR linux_displaced_step_location(struct gdbarch *gdbarch)
Definition: linux-tdep.c:2437
gdb_sys_mount
Definition: linux-record.h:208
gdb_sys_ioprio_get
Definition: linux-record.h:477
glibc-tdep.h
gdb_sys_utimes
Definition: linux-record.h:458
arm_linux_displaced_step_copy_insn
static struct displaced_step_closure * arm_linux_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
Definition: arm-linux-tdep.c:1111
gdb_sys_msgctl
Definition: linux-record.h:539
linux_record_tdep::ioctl_TIOCNOTTY
int ioctl_TIOCNOTTY
Definition: linux-record.h:129
linux_record_tdep::ioctl_TIOCGSERIAL
int ioctl_TIOCGSERIAL
Definition: linux-record.h:125
gdbarch_tdep::jb_elt_size
size_t jb_elt_size
Definition: aarch64-tdep.h:65
gdb_syscall
gdb_syscall
Definition: linux-record.h:183
user-regs.h
gdb_sys_get_mempolicy
Definition: linux-record.h:462
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
gdb_sys_setregid
Definition: linux-record.h:391
INT_REGISTER_SIZE
#define INT_REGISTER_SIZE
Definition: arm.h:97
gdb_sys_fchown
Definition: linux-record.h:394
linux_record_tdep::ioctl_TIOCINQ
int ioctl_TIOCINQ
Definition: linux-record.h:122
gdb_sys_setgid
Definition: linux-record.h:401
gdb_sys_futex
Definition: linux-record.h:427
gdb_sys_sync
Definition: linux-record.h:223
gdb_sys_getresuid
Definition: linux-record.h:396
tramp-frame.h
gdbarch_tdep::arm_syscall_record
int(* arm_syscall_record)(struct regcache *regcache, unsigned long svc_number)
Definition: arm-tdep.h:145
gdb_sys_munlock
Definition: linux-record.h:338
arm_displaced_step_closure::numinsns
int numinsns
Definition: arm-tdep.h:219
set_gdbarch_software_single_step
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype software_single_step)
Definition: gdbarch.c:3258
ARM_FLOAT_FPA
Definition: arm-tdep.h:71
arm_displaced_step_closure::cleanup
void(* cleanup)(struct gdbarch *, struct regcache *, arm_displaced_step_closure *)
Definition: arm-tdep.h:222
linux_record_tdep::ioctl_TIOCSTI
int ioctl_TIOCSTI
Definition: linux-record.h:112
gdb_sys_waitid
Definition: linux-record.h:471
gdb_sys_fremovexattr
Definition: linux-record.h:424
gdb_sys_setresuid16
Definition: linux-record.h:351
gdb_sys_sched_rr_get_interval
Definition: linux-record.h:348
gdb_sys_fallocate
Definition: linux-record.h:507
linux_record_tdep::ioctl_TCSBRKP
int ioctl_TCSBRKP
Definition: linux-record.h:132
linux_record_tdep::size_new_utsname
int size_new_utsname
Definition: linux-record.h:56
arm_get_next_pcs_read_memory_unsigned_integer
ULONGEST arm_get_next_pcs_read_memory_unsigned_integer(CORE_ADDR memaddr, int len, int byte_order)
Definition: arm-tdep.c:6213
gdb_sys_link
Definition: linux-record.h:196
write_exp_elt_opcode
void write_exp_elt_opcode(struct parser_state *ps, enum exp_opcode expelt)
Definition: parse.c:205
arm_linux_sigreturn_init
static void arm_linux_sigreturn_init(const struct tramp_frame *self, struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
Definition: arm-linux-tdep.c:301
gdb_sys_pwrite64
Definition: linux-record.h:368
gdb_sys_acct
Definition: linux-record.h:238
gdb_sys_rmdir
Definition: linux-record.h:227
symtab_and_line
Definition: symtab.h:1746
gdb_sys_epoll_ctl
Definition: linux-record.h:442
gdb_sys_mlock
Definition: linux-record.h:337
linux_record_tdep::size_long
int size_long
Definition: linux-record.h:47
gdb_sys_getxattr
Definition: linux-record.h:416
arm_linux_syscall_record
static int arm_linux_syscall_record(struct regcache *regcache, unsigned long svc_number)
Definition: arm-linux-tdep.c:1661
gdb_sys_rt_sigreturn
Definition: linux-record.h:360
ARM_LINUX_SIZEOF_GREGSET
#define ARM_LINUX_SIZEOF_GREGSET
Definition: arm-linux-tdep.c:474
gdb_sys_inotify_add_watch
Definition: linux-record.h:479
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
gdb_sys_rt_sigprocmask
Definition: linux-record.h:362
gdb_sys_uselib
Definition: linux-record.h:273
typeDouble
#define typeDouble
Definition: arm-linux-tdep.c:546
gdb_sys_lstat
Definition: linux-record.h:271
arm_linux_supply_gregset
void arm_linux_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs_buf, size_t len)
Definition: arm-linux-tdep.c:477
set_gdbarch_displaced_step_copy_insn
void set_gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
Definition: gdbarch.c:3940
set_momentary_breakpoint
breakpoint_up set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
Definition: breakpoint.c:8545
gdb_sys_mkdir
Definition: linux-record.h:226
gdb_sys_statfs64
Definition: linux-record.h:455
gdbarch_tdep::thumb2_breakpoint
const gdb_byte * thumb2_breakpoint
Definition: arm-tdep.h:128
gdb_sys_ioctl
Definition: linux-record.h:241
linux_record_tdep::ioctl_TIOCGLCKTRMIOS
int ioctl_TIOCGLCKTRMIOS
Definition: linux-record.h:149
arm_linux_collect_nwfpe
void arm_linux_collect_nwfpe(const struct regset *regset, const struct regcache *regcache, int regnum, void *regs_buf, size_t len)
Definition: arm-linux-tdep.c:639
arm_linux_arm_be_breakpoint
static const gdb_byte arm_linux_arm_be_breakpoint[]
Definition: arm-linux-tdep.c:68
gdb_sys_geteuid16
Definition: linux-record.h:236
gdb_sys_shmat
Definition: linux-record.h:530
arm_linux_gregset
static const struct regset arm_linux_gregset
Definition: arm-linux-tdep.c:693
gdb_sys_getgroups
Definition: linux-record.h:392
gdb_sys_uname
Definition: linux-record.h:296
gdb_sys_epoll_pwait
Definition: linux-record.h:506
gdb_sys_getgid
Definition: linux-record.h:387
linux_record_tdep::size_serial_struct
int size_serial_struct
Definition: linux-record.h:87
gdbarch_tdep::thumb2_breakpoint_size
int thumb2_breakpoint_size
Definition: arm-tdep.h:129
gdb_sys_chown
Definition: linux-record.h:399
linux_record_tdep::ioctl_TIOCOUTQ
int ioctl_TIOCOUTQ
Definition: linux-record.h:111
gdb_sys_stat64
Definition: linux-record.h:382
gdb_sys_ustat
Definition: linux-record.h:249
gdb_stderr
#define gdb_stderr
Definition: utils.h:344
linux_record_tdep::ioctl_TCSBRK
int ioctl_TCSBRK
Definition: linux-record.h:103
gdb_sys_mremap
Definition: linux-record.h:350
gdbcore.h
_initialize_arm_linux_tdep
void _initialize_arm_linux_tdep(void)
Definition: arm-linux-tdep.c:1998
gdb_sys_fcntl
Definition: linux-record.h:242
gdb_sys_getpeername
Definition: linux-record.h:524
linux_record_tdep::size_fd_set
int size_fd_set
Definition: linux-record.h:41
gdb_sys_capget
Definition: linux-record.h:371
gdb_sys_clone
Definition: linux-record.h:307
gdb_sys_mincore
Definition: linux-record.h:405
thread_info::control
thread_control_state control
Definition: gdbthread.h:291
gdb_sys_personality
Definition: linux-record.h:323
ARM_FLOAT_AUTO
Definition: arm-tdep.h:69
arm_displaced_step_closure::modinsn
unsigned long modinsn[DISPLACED_MODIFIED_INSNS]
Definition: arm-tdep.h:218
regcache_read_pc
CORE_ADDR regcache_read_pc(struct regcache *regcache)
Definition: regcache.c:1229
target_desc
Definition: target-descriptions.c:591
arm_linux_get_syscall_number
static LONGEST arm_linux_get_syscall_number(struct gdbarch *gdbarch, ptid_t ptid)
Definition: arm-linux-tdep.c:824
gdb_sys_chroot
Definition: linux-record.h:248
supply_nwfpe_register
void supply_nwfpe_register(struct regcache *regcache, int regno, const gdb_byte *regs)
Definition: arm-linux-tdep.c:550
linux-record.h
set_gdbarch_stap_is_single_operand
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype stap_is_single_operand)
Definition: gdbarch.c:4475
ARM_FLOAT_VFP
Definition: arm-tdep.h:73
arm_linux_thumb_le_breakpoint
static const gdb_byte arm_linux_thumb_le_breakpoint[]
Definition: arm-linux-tdep.c:85
gdb_sys_clock_nanosleep
Definition: linux-record.h:454
ARM_SET_R7_SIGRETURN
#define ARM_SET_R7_SIGRETURN
Definition: arm-linux-tdep.c:244
THUMB2_SET_R7_RT_SIGRETURN1
#define THUMB2_SET_R7_RT_SIGRETURN1
Definition: arm-linux-tdep.c:251
arm_linux_sigreturn_return_addr
static int arm_linux_sigreturn_return_addr(struct frame_info *frame, unsigned long svc_number, CORE_ADDR *pc, int *is_thumb)
Definition: arm-linux-tdep.c:761
gdb_sys_sysctl
Definition: linux-record.h:336
gdb_sys_fork
Definition: linux-record.h:189
ARM_LINUX_SIGRETURN_INSTR
#define ARM_LINUX_SIGRETURN_INSTR
Definition: arm-linux-tdep.c:237
ARM_LDR_PC_SP_4
#define ARM_LDR_PC_SP_4
Definition: arm-linux-tdep.c:259
gdb_sys_exit_group
Definition: linux-record.h:439
gdb_sys_getcpu
Definition: linux-record.h:505
gdb_sys_fstatfs
Definition: linux-record.h:287
ARM_PS_REGNUM
Definition: arm.h:36
ARM_ABI_AAPCS
Definition: arm-tdep.h:82
linux_record_tdep::ioctl_TIOCMGET
int ioctl_TIOCMGET
Definition: linux-record.h:115
offset
int offset
Definition: agent.c:65
set_gdbarch_get_syscall_number
void set_gdbarch_get_syscall_number(struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype get_syscall_number)
Definition: gdbarch.c:4281
gdb_sys_llistxattr
Definition: linux-record.h:420
linux_record_tdep::size_stat
int size_stat
Definition: linux-record.h:51
linux_record_tdep::ioctl_TIOCSSERIAL
int ioctl_TIOCSSERIAL
Definition: linux-record.h:126
tramp_frame_prepend_unwinder
void tramp_frame_prepend_unwinder(struct gdbarch *gdbarch, const struct tramp_frame *tramp_frame)
Definition: tramp-frame.c:146
gdbarch_tdep::vfp_register_count
int vfp_register_count
Definition: arm-tdep.h:107
arm_stap_is_single_operand
static int arm_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
Definition: arm-linux-tdep.c:1144
linux_record_tdep::size_old_sigset_t
int size_old_sigset_t
Definition: linux-record.h:34
gdb_sys_mprotect
Definition: linux-record.h:312
regcache::arch
gdbarch * arch() const
Definition: regcache.c:221
linux_record_tdep::size_NFS_FHSIZE
int size_NFS_FHSIZE
Definition: linux-record.h:63
gdb_sys_setgid16
Definition: linux-record.h:233
arm_get_next_pcs_is_thumb
int arm_get_next_pcs_is_thumb(struct arm_get_next_pcs *self)
Definition: arm-tdep.c:6240
gdb_sys_symlink
Definition: linux-record.h:270
linux-tdep.h
arm_linux_cleanup_svc
static void arm_linux_cleanup_svc(struct gdbarch *gdbarch, struct regcache *regs, arm_displaced_step_closure *dsc)
Definition: arm-linux-tdep.c:951
symtab_and_line::pc
CORE_ADDR pc
Definition: symtab.h:1759
linux_record_tdep::size_mem_dqinfo
int size_mem_dqinfo
Definition: linux-record.h:58
gdb_sys_lseek
Definition: linux-record.h:206
linux_record_tdep::size_fs_quota_stat
int size_fs_quota_stat
Definition: linux-record.h:60
arm_linux_rt_sigreturn_init
static void arm_linux_rt_sigreturn_init(const struct tramp_frame *self, struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func)
Definition: arm-linux-tdep.c:321
gdb_sys_listxattr
Definition: linux-record.h:419
linux_record_tdep::size_old_utsname
int size_old_utsname
Definition: linux-record.h:52
gdb_sys_setgroups
Definition: linux-record.h:393
gdb_sys_sendmsg
Definition: linux-record.h:518
target.h
gdb_sys_getsockopt
Definition: linux-record.h:527
linux_record_tdep::size_if_dqblk
int size_if_dqblk
Definition: linux-record.h:59
ARM_SP_REGNUM
Definition: arm.h:29
arm_get_next_pcs_ctor
void arm_get_next_pcs_ctor(struct arm_get_next_pcs *self, struct arm_get_next_pcs_ops *ops, int byte_order, int byte_order_for_code, int has_thumb2_breakpoint, struct regcache *regcache)
Definition: arm-get-next-pcs.c:29
gdb_sys_sendfile
Definition: linux-record.h:374
value.h
linux_record_tdep::ioctl_TIOCGSID
int ioctl_TIOCGSID
Definition: linux-record.h:136
gdb_sys_mmap2
Definition: linux-record.h:379
gdb_sys_getegid
Definition: linux-record.h:389
linux_record_tdep::size_int
int size_int
Definition: linux-record.h:46
linux_record_tdep::fcntl_F_SETLKW64
int fcntl_F_SETLKW64
Definition: linux-record.h:166
gdbarch::byte_order_for_code
enum bfd_endian byte_order_for_code
Definition: gdbarch.c:138
gdb_sys_lstat64
Definition: linux-record.h:383
gdb_sys_sched_get_priority_max
Definition: linux-record.h:346
ARM_RT_SIGRETURN
#define ARM_RT_SIGRETURN
Definition: arm-linux-tdep.c:264
gdb_sys_alarm
Definition: linux-record.h:214
gdb_sys_truncate
Definition: linux-record.h:279
regcache_raw_supply
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1004
gdb_sys_sched_get_priority_min
Definition: linux-record.h:347
linux_record_tdep::ioctl_TIOCSETD
int ioctl_TIOCSETD
Definition: linux-record.h:130
linux_record_tdep::size_stat64
int size_stat64
Definition: linux-record.h:72
arm_linux_thumb_be_breakpoint
static const gdb_byte arm_linux_thumb_be_breakpoint[]
Definition: arm-linux-tdep.c:83
gdb_sys_io_submit
Definition: linux-record.h:435
gdbtypes.h
gdb_sys_setsockopt
Definition: linux-record.h:526
gdb_sys_io_cancel
Definition: linux-record.h:436
DISPLACED_MODIFIED_INSNS
#define DISPLACED_MODIFIED_INSNS
Definition: aarch64-tdep.h:52
linux_record_tdep::size_timeval
int size_timeval
Definition: linux-record.h:37
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
linux_record_tdep::ioctl_FIONREAD
int ioctl_FIONREAD
Definition: linux-record.h:121
gdb_sys_timer_gettime
Definition: linux-record.h:448
arm_canonicalize_syscall
static enum gdb_syscall arm_canonicalize_syscall(int syscall)
Definition: arm-linux-tdep.c:1270
regcache
Definition: regcache.h:232
gdb_sys_set_mempolicy
Definition: linux-record.h:463
linux_record_tdep::ioctl_TIOCMBIS
int ioctl_TIOCMBIS
Definition: linux-record.h:116
linux_record_tdep::size_stack_t
int size_stack_t
Definition: linux-record.h:70
gdbarch_info
Definition: gdbarch.h:1626
gdb_sys_futimesat
Definition: linux-record.h:486
gdb_stdlog
#define gdb_stdlog
Definition: utils.h:349
linux_record_tdep::ioctl_TIOCSERGETLSR
int ioctl_TIOCSERGETLSR
Definition: linux-record.h:152
gdb_sys_select
Definition: linux-record.h:329
linux_record_tdep::ioctl_TCGETS
int ioctl_TCGETS
Definition: linux-record.h:95
linux_record_tdep::ioctl_TIOCGHAYESESP
int ioctl_TIOCGHAYESESP
Definition: linux-record.h:157
gdbarch_info::byte_order_for_code
enum bfd_endian byte_order_for_code
Definition: gdbarch.h:1634
arm_linux_fpregset
static const struct regset arm_linux_fpregset
Definition: arm-linux-tdep.c:698
linux_record_tdep::size_siginfo_t
int size_siginfo_t
Definition: linux-record.h:68
gdb_sys_reboot
Definition: linux-record.h:275
arm_displaced_step_closure::u
union arm_displaced_step_closure::@5 u
ARM_UCONTEXT_SIGCONTEXT
#define ARM_UCONTEXT_SIGCONTEXT
Definition: arm-linux.h:58
gdb_sys_writev
Definition: linux-record.h:333
regcache_raw_collect
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1085
linux_record_tdep::ioctl_TIOCMIWAIT
int ioctl_TIOCMIWAIT
Definition: linux-record.h:155
HWCAP_VFP
#define HWCAP_VFP
Definition: arm-fbsd-tdep.h:34
gdb_sys_vmsplice
Definition: linux-record.h:503
linux_record_tdep::size_mq_attr
int size_mq_attr
Definition: linux-record.h:82
gdb_sys_fcntl64
Definition: linux-record.h:408
ARM_CPSR_GREGNUM
#define ARM_CPSR_GREGNUM
Definition: arm-linux.h:24
regset.h
arm_displaced_step_closure::insn_addr
CORE_ADDR insn_addr
Definition: arm-tdep.h:220
gdb_sys_lchown
Definition: linux-record.h:385
linux_record_tdep::size_timezone
int size_timezone
Definition: linux-record.h:38
linux_record_tdep::ioctl_TCSETSF
int ioctl_TCSETSF
Definition: linux-record.h:98
linux_record_tdep::ioctl_FIOQSIZE
int ioctl_FIOQSIZE
Definition: linux-record.h:159
ARM_SET_R7_RT_SIGRETURN
#define ARM_SET_R7_RT_SIGRETURN
Definition: arm-linux-tdep.c:245
gdb_sys_dup
Definition: linux-record.h:228
arm_displaced_step_closure::tmp
ULONGEST tmp[DISPLACED_TEMPS]
Definition: arm-tdep.h:159
gdb_sys_ipc
Definition: linux-record.h:304
gdb_sys_restart_syscall
Definition: linux-record.h:187
linux_record_tdep::size_hayes_esp_config
int size_hayes_esp_config
Definition: linux-record.h:89
gdb_sys_removexattr
Definition: linux-record.h:422
gdb_sys_delete_module
Definition: linux-record.h:316
tramp_frame
Definition: tramp-frame.h:46
thread_control_state::step_resume_breakpoint
struct breakpoint * step_resume_breakpoint
Definition: gdbthread.h:55
gdb_sys_fchmodat
Definition: linux-record.h:493
arm_kernel_linux_restart_syscall_tramp_frame
static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame
Definition: arm-linux-tdep.c:461
gdb_sys_setgroups16
Definition: linux-record.h:268
linux_record_tdep::ioctl_TIOCSERGWILD
int ioctl_TIOCSERGWILD
Definition: linux-record.h:147
gdb_sys_msync
Definition: linux-record.h:331
linux_record_tdep::size_msghdr
int size_msghdr
Definition: linux-record.h:49
arm_linux_iterate_over_regset_sections
static void arm_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
Definition: arm-linux-tdep.c:711
linux_record_tdep::size_off_t
int size_off_t
Definition: linux-record.h:71
gdb_sys_tkill
Definition: linux-record.h:425
gdb_sys_timer_create
Definition: linux-record.h:446
read_memory_unsigned_integer
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:326
linux_record_tdep::arg6
int arg6
Definition: linux-record.h:175
gdb_sys_linkat
Definition: linux-record.h:490
set_gdbarch_iterate_over_regset_sections
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
Definition: gdbarch.c:3647
regcache::ptid
ptid_t ptid() const
Definition: regcache.h:325
arm_linux_init_abi
static void arm_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: arm-linux-tdep.c:1716
gdb_sys_msgrcv
Definition: linux-record.h:538
ARM_LINUX_RT_SIGRETURN_INSTR
#define ARM_LINUX_RT_SIGRETURN_INSTR
Definition: arm-linux-tdep.c:238
ARM_FPS_REGNUM
Definition: arm.h:35
gdb_sys_ftruncate
Definition: linux-record.h:280
linux_record_tdep::size_itimerval
int size_itimerval
Definition: linux-record.h:50
linux_record_tdep::size__old_kernel_stat
int size__old_kernel_stat
Definition: linux-record.h:27
gdb_sys_umount
Definition: linux-record.h:239
gdb_sys_sched_getscheduler
Definition: linux-record.h:344
gdb_sys_times
Definition: linux-record.h:230
gdb_sys_chmod
Definition: linux-record.h:202
linux_record_tdep::ioctl_TCSETAW
int ioctl_TCSETAW
Definition: linux-record.h:101
gdb_sys_connect
Definition: linux-record.h:514
gdb_sys_nfsservctl
Definition: linux-record.h:356
linux_record_tdep::ioctl_TIOCPKT
int ioctl_TIOCPKT
Definition: linux-record.h:127
set_gdbarch_skip_solib_resolver
void set_gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
Definition: gdbarch.c:3333
gdb_sys_settimeofday
Definition: linux-record.h:266
gdb_sys_wait4
Definition: linux-record.h:301
linux_record_tdep::ioctl_TIOCNXCL
int ioctl_TIOCNXCL
Definition: linux-record.h:107
linux_record_tdep::size_PAGE_SIZE
int size_PAGE_SIZE
Definition: linux-record.h:75
linux_record_tdep::size_old_uid_t
int size_old_uid_t
Definition: linux-record.h:40
gdb_sys_sched_getaffinity
Definition: linux-record.h:429
gdb_sys_semtimedop
Definition: linux-record.h:540
stoken
Definition: parser-defs.h:88
HWCAP_VFPv3
#define HWCAP_VFPv3
Definition: arm-fbsd-tdep.h:36
gdbarch::byte_order
enum bfd_endian byte_order
Definition: gdbarch.c:137
ARM_NEW_RT_SIGFRAME_UCONTEXT
#define ARM_NEW_RT_SIGFRAME_UCONTEXT
Definition: arm-linux.h:67
ARM_PC_REGNUM
Definition: arm.h:31
gdb_sys_accept
Definition: linux-record.h:515
gdbarch_byte_order_for_code
enum bfd_endian gdbarch_byte_order_for_code(struct gdbarch *gdbarch)
Definition: gdbarch.c:1518
arm.h
gdb_sys_geteuid
Definition: linux-record.h:388
tdesc_arm_with_vfpv3
struct target_desc * tdesc_arm_with_vfpv3
Definition: arm-with-vfpv3.c:8
write_exp_string
void write_exp_string(struct parser_state *ps, struct stoken str)
Definition: parse.c:318
set_gdbarch_core_read_description
void set_gdbarch_core_read_description(struct gdbarch *gdbarch, gdbarch_core_read_description_ftype core_read_description)
Definition: gdbarch.c:4072
linux_record_tdep::size_io_event
int size_io_event
Definition: linux-record.h:78
linux_record_tdep::fcntl_F_SETLK64
int fcntl_F_SETLK64
Definition: linux-record.h:165
write_exp_elt_type
void write_exp_elt_type(struct parser_state *ps, struct type *expelt)
Definition: parse.c:277
gdb_sys_poll
Definition: linux-record.h:355
linux_record_tdep::ioctl_TIOCGSOFTCAR
int ioctl_TIOCGSOFTCAR
Definition: linux-record.h:119
linux_record_tdep::ioctl_TCSETSW2
int ioctl_TCSETSW2
Definition: linux-record.h:139
error
void error(const char *fmt,...)
Definition: errors.c:38
linux_record_tdep::size_rusage
int size_rusage
Definition: linux-record.h:36
linux_record_tdep::ioctl_FIONCLEX
int ioctl_FIONCLEX
Definition: linux-record.h:143
linux_record_tdep::size_sigaction
int size_sigaction
Definition: linux-record.h:66
arm_catch_kernel_helper_return
static void arm_catch_kernel_helper_return(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs, arm_displaced_step_closure *dsc)
Definition: arm-linux-tdep.c:1079
gdb_sys_munlockall
Definition: linux-record.h:340
arm_eabi_linux_rt_sigreturn_tramp_frame
static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame
Definition: arm-linux-tdep.c:415
linux_record_tdep::ioctl_TCSETS
int ioctl_TCSETS
Definition: linux-record.h:96
CANNOT_WRITE_PC
Definition: arm-tdep.h:236
gdb_sys_write
Definition: linux-record.h:191
arm_displaced_step_closure
Definition: arm-tdep.h:157
ARM_EABI_SYSCALL
#define ARM_EABI_SYSCALL
Definition: arm-linux-tdep.c:246
arm_skip_stub
CORE_ADDR arm_skip_stub(struct frame_info *frame, CORE_ADDR pc)
Definition: arm-tdep.c:8282
gdb_sys_fstat64
Definition: linux-record.h:384
gdb_sys_unlink
Definition: linux-record.h:197
gdb_sys_flock
Definition: linux-record.h:330
gdb_sys_msgget
Definition: linux-record.h:536
ARM_LINUX_SIZEOF_NWFPE
#define ARM_LINUX_SIZEOF_NWFPE
Definition: arm-linux-tdep.h:23
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
arm_linux_core_read_description
static const struct target_desc * arm_linux_core_read_description(struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
Definition: arm-linux-tdep.c:731
gdbarch_tdep::arm_breakpoint_size
int arm_breakpoint_size
Definition: arm-tdep.h:120
LONGEST
long long LONGEST
Definition: common-types.h:52
symtab_and_line::explicit_pc
bool explicit_pc
Definition: symtab.h:1761
arm_linux_arm_le_breakpoint
static const gdb_byte arm_linux_arm_le_breakpoint[]
Definition: arm-linux-tdep.c:66
ARM_F0_REGNUM
Definition: arm.h:32
linux_record_tdep::size_tms
int size_tms
Definition: linux-record.h:28
gdb_sys_remap_file_pages
Definition: linux-record.h:444
gdb_sys_renameat
Definition: linux-record.h:489
gdb_sys_inotify_init
Definition: linux-record.h:478
stoken::length
int length
Definition: parser-defs.h:93
symfile.h
linux_record_tdep::ioctl_TIOCGETD
int ioctl_TIOCGETD
Definition: linux-record.h:131
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
linux_record_tdep::ioctl_TIOCMSET
int ioctl_TIOCMSET
Definition: linux-record.h:118
gdb_sys_bdflush
Definition: linux-record.h:321
gdb_sys_setreuid16
Definition: linux-record.h:257
gdb_sys_stime
Definition: linux-record.h:212
gdb_sys_mkdirat
Definition: linux-record.h:483
linux_record_tdep::size_iocb
int size_iocb
Definition: linux-record.h:79
gdb_sys_dup3
Definition: linux-record.h:510
gdb_sys_vhangup
Definition: linux-record.h:298
gdb_sys_close
Definition: linux-record.h:193
gdb_sys_getresgid
Definition: linux-record.h:398
gdb_sys_fchdir
Definition: linux-record.h:320
gdb_sys_llseek
Definition: linux-record.h:327
arm_linux_skip_trampoline_code
static CORE_ADDR arm_linux_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)
Definition: arm-linux-tdep.c:1705
MAKE_THUMB_ADDR
#define MAKE_THUMB_ADDR(addr)
Definition: arm.h:102