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