GDB (xrefs)
/tmp/gdb-7.10/gdb/arm-linux-tdep.c
Go to the documentation of this file.
1 /* GNU/Linux on ARM target support.
2 
3  Copyright (C) 1999-2015 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 "floatformat.h"
25 #include "gdbcore.h"
26 #include "frame.h"
27 #include "regcache.h"
28 #include "doublest.h"
29 #include "solib-svr4.h"
30 #include "osabi.h"
31 #include "regset.h"
32 #include "trad-frame.h"
33 #include "tramp-frame.h"
34 #include "breakpoint.h"
35 #include "auxv.h"
36 #include "xml-syscall.h"
37 
38 #include "arm-tdep.h"
39 #include "arm-linux-tdep.h"
40 #include "linux-tdep.h"
41 #include "glibc-tdep.h"
42 #include "arch-utils.h"
43 #include "inferior.h"
44 #include "infrun.h"
45 #include "gdbthread.h"
46 #include "symfile.h"
47 
48 #include "record-full.h"
49 #include "linux-record.h"
50 
51 #include "cli/cli-utils.h"
52 #include "stap-probe.h"
53 #include "parser-defs.h"
54 #include "user-regs.h"
55 #include <ctype.h>
56 #include "elf/common.h"
57 extern int arm_apcs_32;
58 
59 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
60  is to execute a particular software interrupt, rather than use a
61  particular undefined instruction to provoke a trap. Upon exection
62  of the software interrupt the kernel stops the inferior with a
63  SIGTRAP, and wakes the debugger. */
64 
65 static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
66 
67 static const gdb_byte arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
68 
69 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
70  the operand of the swi if old-ABI compatibility is disabled. Therefore,
71  use an undefined instruction instead. This is supported as of kernel
72  version 2.5.70 (May 2003), so should be a safe assumption for EABI
73  binaries. */
74 
75 static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
76 
77 static const gdb_byte eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
78 
79 /* All the kernels which support Thumb support using a specific undefined
80  instruction for the Thumb breakpoint. */
81 
82 static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
83 
84 static const gdb_byte arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
85 
86 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
87  we must use a length-appropriate breakpoint for 32-bit Thumb
88  instructions. See also thumb_get_next_pc. */
89 
90 static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };
91 
92 static const gdb_byte arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 };
93 
94 /* Description of the longjmp buffer. The buffer is treated as an array of
95  elements of size ARM_LINUX_JB_ELEMENT_SIZE.
96 
97  The location of saved registers in this buffer (in particular the PC
98  to use after longjmp is called) varies depending on the ABI (in
99  particular the FP model) and also (possibly) the C Library.
100 
101  For glibc, eglibc, and uclibc the following holds: If the FP model is
102  SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
103  buffer. This is also true for the SoftFPA model. However, for the FPA
104  model the PC is at offset 21 in the buffer. */
105 #define ARM_LINUX_JB_ELEMENT_SIZE INT_REGISTER_SIZE
106 #define ARM_LINUX_JB_PC_FPA 21
107 #define ARM_LINUX_JB_PC_EABI 9
108 
109 /*
110  Dynamic Linking on ARM GNU/Linux
111  --------------------------------
112 
113  Note: PLT = procedure linkage table
114  GOT = global offset table
115 
116  As much as possible, ELF dynamic linking defers the resolution of
117  jump/call addresses until the last minute. The technique used is
118  inspired by the i386 ELF design, and is based on the following
119  constraints.
120 
121  1) The calling technique should not force a change in the assembly
122  code produced for apps; it MAY cause changes in the way assembly
123  code is produced for position independent code (i.e. shared
124  libraries).
125 
126  2) The technique must be such that all executable areas must not be
127  modified; and any modified areas must not be executed.
128 
129  To do this, there are three steps involved in a typical jump:
130 
131  1) in the code
132  2) through the PLT
133  3) using a pointer from the GOT
134 
135  When the executable or library is first loaded, each GOT entry is
136  initialized to point to the code which implements dynamic name
137  resolution and code finding. This is normally a function in the
138  program interpreter (on ARM GNU/Linux this is usually
139  ld-linux.so.2, but it does not have to be). On the first
140  invocation, the function is located and the GOT entry is replaced
141  with the real function address. Subsequent calls go through steps
142  1, 2 and 3 and end up calling the real code.
143 
144  1) In the code:
145 
146  b function_call
147  bl function_call
148 
149  This is typical ARM code using the 26 bit relative branch or branch
150  and link instructions. The target of the instruction
151  (function_call is usually the address of the function to be called.
152  In position independent code, the target of the instruction is
153  actually an entry in the PLT when calling functions in a shared
154  library. Note that this call is identical to a normal function
155  call, only the target differs.
156 
157  2) In the PLT:
158 
159  The PLT is a synthetic area, created by the linker. It exists in
160  both executables and libraries. It is an array of stubs, one per
161  imported function call. It looks like this:
162 
163  PLT[0]:
164  str lr, [sp, #-4]! @push the return address (lr)
165  ldr lr, [pc, #16] @load from 6 words ahead
166  add lr, pc, lr @form an address for GOT[0]
167  ldr pc, [lr, #8]! @jump to the contents of that addr
168 
169  The return address (lr) is pushed on the stack and used for
170  calculations. The load on the second line loads the lr with
171  &GOT[3] - . - 20. The addition on the third leaves:
172 
173  lr = (&GOT[3] - . - 20) + (. + 8)
174  lr = (&GOT[3] - 12)
175  lr = &GOT[0]
176 
177  On the fourth line, the pc and lr are both updated, so that:
178 
179  pc = GOT[2]
180  lr = &GOT[0] + 8
181  = &GOT[2]
182 
183  NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
184  "tight", but allows us to keep all the PLT entries the same size.
185 
186  PLT[n+1]:
187  ldr ip, [pc, #4] @load offset from gotoff
188  add ip, pc, ip @add the offset to the pc
189  ldr pc, [ip] @jump to that address
190  gotoff: .word GOT[n+3] - .
191 
192  The load on the first line, gets an offset from the fourth word of
193  the PLT entry. The add on the second line makes ip = &GOT[n+3],
194  which contains either a pointer to PLT[0] (the fixup trampoline) or
195  a pointer to the actual code.
196 
197  3) In the GOT:
198 
199  The GOT contains helper pointers for both code (PLT) fixups and
200  data fixups. The first 3 entries of the GOT are special. The next
201  M entries (where M is the number of entries in the PLT) belong to
202  the PLT fixups. The next D (all remaining) entries belong to
203  various data fixups. The actual size of the GOT is 3 + M + D.
204 
205  The GOT is also a synthetic area, created by the linker. It exists
206  in both executables and libraries. When the GOT is first
207  initialized , all the GOT entries relating to PLT fixups are
208  pointing to code back at PLT[0].
209 
210  The special entries in the GOT are:
211 
212  GOT[0] = linked list pointer used by the dynamic loader
213  GOT[1] = pointer to the reloc table for this module
214  GOT[2] = pointer to the fixup/resolver code
215 
216  The first invocation of function call comes through and uses the
217  fixup/resolver code. On the entry to the fixup/resolver code:
218 
219  ip = &GOT[n+3]
220  lr = &GOT[2]
221  stack[0] = return address (lr) of the function call
222  [r0, r1, r2, r3] are still the arguments to the function call
223 
224  This is enough information for the fixup/resolver code to work
225  with. Before the fixup/resolver code returns, it actually calls
226  the requested function and repairs &GOT[n+3]. */
227 
228 /* The constants below were determined by examining the following files
229  in the linux kernel sources:
230 
231  arch/arm/kernel/signal.c
232  - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
233  include/asm-arm/unistd.h
234  - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
235 
236 #define ARM_LINUX_SIGRETURN_INSTR 0xef900077
237 #define ARM_LINUX_RT_SIGRETURN_INSTR 0xef9000ad
238 
239 /* For ARM EABI, the syscall number is not in the SWI instruction
240  (instead it is loaded into r7). We recognize the pattern that
241  glibc uses... alternatively, we could arrange to do this by
242  function name, but they are not always exported. */
243 #define ARM_SET_R7_SIGRETURN 0xe3a07077
244 #define ARM_SET_R7_RT_SIGRETURN 0xe3a070ad
245 #define ARM_EABI_SYSCALL 0xef000000
246 
247 /* Equivalent patterns for Thumb2. */
248 #define THUMB2_SET_R7_SIGRETURN1 0xf04f
249 #define THUMB2_SET_R7_SIGRETURN2 0x0777
250 #define THUMB2_SET_R7_RT_SIGRETURN1 0xf04f
251 #define THUMB2_SET_R7_RT_SIGRETURN2 0x07ad
252 #define THUMB2_EABI_SYSCALL 0xdf00
253 
254 /* OABI syscall restart trampoline, used for EABI executables too
255  whenever OABI support has been enabled in the kernel. */
256 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
257 #define ARM_LDR_PC_SP_12 0xe49df00c
258 #define ARM_LDR_PC_SP_4 0xe49df004
259 
260 static void
262  struct trad_frame_cache *this_cache,
263  CORE_ADDR func, int regs_offset)
264 {
266  CORE_ADDR base = sp + regs_offset;
267  int i;
268 
269  for (i = 0; i < 16; i++)
270  trad_frame_set_reg_addr (this_cache, i, base + i * 4);
271 
272  trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
273 
274  /* The VFP or iWMMXt registers may be saved on the stack, but there's
275  no reliable way to restore them (yet). */
276 
277  /* Save a frame ID. */
278  trad_frame_set_id (this_cache, frame_id_build (sp, func));
279 }
280 
281 /* There are a couple of different possible stack layouts that
282  we need to support.
283 
284  Before version 2.6.18, the kernel used completely independent
285  layouts for non-RT and RT signals. For non-RT signals the stack
286  began directly with a struct sigcontext. For RT signals the stack
287  began with two redundant pointers (to the siginfo and ucontext),
288  and then the siginfo and ucontext.
289 
290  As of version 2.6.18, the non-RT signal frame layout starts with
291  a ucontext and the RT signal frame starts with a siginfo and then
292  a ucontext. Also, the ucontext now has a designated save area
293  for coprocessor registers.
294 
295  For RT signals, it's easy to tell the difference: we look for
296  pinfo, the pointer to the siginfo. If it has the expected
297  value, we have an old layout. If it doesn't, we have the new
298  layout.
299 
300  For non-RT signals, it's a bit harder. We need something in one
301  layout or the other with a recognizable offset and value. We can't
302  use the return trampoline, because ARM usually uses SA_RESTORER,
303  in which case the stack return trampoline is not filled in.
304  We can't use the saved stack pointer, because sigaltstack might
305  be in use. So for now we guess the new layout... */
306 
307 /* There are three words (trap_no, error_code, oldmask) in
308  struct sigcontext before r0. */
309 #define ARM_SIGCONTEXT_R0 0xc
310 
311 /* There are five words (uc_flags, uc_link, and three for uc_stack)
312  in the ucontext_t before the sigcontext. */
313 #define ARM_UCONTEXT_SIGCONTEXT 0x14
314 
315 /* There are three elements in an rt_sigframe before the ucontext:
316  pinfo, puc, and info. The first two are pointers and the third
317  is a struct siginfo, with size 128 bytes. We could follow puc
318  to the ucontext, but it's simpler to skip the whole thing. */
319 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
320 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
321 
322 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
323 
324 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
325 
326 static void
328  struct frame_info *this_frame,
329  struct trad_frame_cache *this_cache,
330  CORE_ADDR func)
331 {
332  struct gdbarch *gdbarch = get_frame_arch (this_frame);
333  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
335  ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
336 
337  if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
338  arm_linux_sigtramp_cache (this_frame, this_cache, func,
341  else
342  arm_linux_sigtramp_cache (this_frame, this_cache, func,
344 }
345 
346 static void
348  struct frame_info *this_frame,
349  struct trad_frame_cache *this_cache,
350  CORE_ADDR func)
351 {
352  struct gdbarch *gdbarch = get_frame_arch (this_frame);
353  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
355  ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
356 
357  if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
358  arm_linux_sigtramp_cache (this_frame, this_cache, func,
362  else
363  arm_linux_sigtramp_cache (this_frame, this_cache, func,
367 }
368 
369 static void
371  struct frame_info *this_frame,
372  struct trad_frame_cache *this_cache,
373  CORE_ADDR func)
374 {
375  struct gdbarch *gdbarch = get_frame_arch (this_frame);
377  CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4);
379  ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
380  int sp_offset;
381 
382  /* There are two variants of this trampoline; with older kernels, the
383  stub is placed on the stack, while newer kernels use the stub from
384  the vector page. They are identical except that the older version
385  increments SP by 12 (to skip stored PC and the stub itself), while
386  the newer version increments SP only by 4 (just the stored PC). */
387  if (self->insn[1].bytes == ARM_LDR_PC_SP_4)
388  sp_offset = 4;
389  else
390  sp_offset = 12;
391 
392  /* Update Thumb bit in CPSR. */
393  if (pc & 1)
394  cpsr |= t_bit;
395  else
396  cpsr &= ~t_bit;
397 
398  /* Remove Thumb bit from PC. */
399  pc = gdbarch_addr_bits_remove (gdbarch, pc);
400 
401  /* Save previous register values. */
402  trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset);
403  trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc);
404  trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr);
405 
406  /* Save a frame ID. */
407  trad_frame_set_id (this_cache, frame_id_build (sp, func));
408 }
409 
410 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
412  4,
413  {
416  },
418 };
419 
420 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
422  4,
423  {
426  },
428 };
429 
430 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
432  4,
433  {
434  { ARM_SET_R7_SIGRETURN, -1 },
435  { ARM_EABI_SYSCALL, -1 },
437  },
439 };
440 
441 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
443  4,
444  {
445  { ARM_SET_R7_RT_SIGRETURN, -1 },
446  { ARM_EABI_SYSCALL, -1 },
448  },
450 };
451 
452 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = {
454  2,
455  {
456  { THUMB2_SET_R7_SIGRETURN1, -1 },
457  { THUMB2_SET_R7_SIGRETURN2, -1 },
458  { THUMB2_EABI_SYSCALL, -1 },
460  },
462 };
463 
464 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = {
466  2,
467  {
470  { THUMB2_EABI_SYSCALL, -1 },
472  },
474 };
475 
476 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
477  NORMAL_FRAME,
478  4,
479  {
481  { ARM_LDR_PC_SP_12, -1 },
483  },
485 };
486 
487 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
488  NORMAL_FRAME,
489  4,
490  {
492  { ARM_LDR_PC_SP_4, -1 },
494  },
496 };
497 
498 /* Core file and register set support. */
499 
500 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
501 
502 void
504  struct regcache *regcache,
505  int regnum, const void *gregs_buf, size_t len)
506 {
507  struct gdbarch *gdbarch = get_regcache_arch (regcache);
508  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
509  const gdb_byte *gregs = gregs_buf;
510  int regno;
511  CORE_ADDR reg_pc;
512  gdb_byte pc_buf[INT_REGISTER_SIZE];
513 
514  for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
515  if (regnum == -1 || regnum == regno)
516  regcache_raw_supply (regcache, regno,
517  gregs + INT_REGISTER_SIZE * regno);
518 
519  if (regnum == ARM_PS_REGNUM || regnum == -1)
520  {
521  if (arm_apcs_32)
524  else
526  gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
527  }
528 
529  if (regnum == ARM_PC_REGNUM || regnum == -1)
530  {
531  reg_pc = extract_unsigned_integer (gregs
532  + INT_REGISTER_SIZE * ARM_PC_REGNUM,
533  INT_REGISTER_SIZE, byte_order);
534  reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
535  store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
536  regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
537  }
538 }
539 
540 void
542  const struct regcache *regcache,
543  int regnum, void *gregs_buf, size_t len)
544 {
545  gdb_byte *gregs = gregs_buf;
546  int regno;
547 
548  for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
549  if (regnum == -1 || regnum == regno)
550  regcache_raw_collect (regcache, regno,
551  gregs + INT_REGISTER_SIZE * regno);
552 
553  if (regnum == ARM_PS_REGNUM || regnum == -1)
554  {
555  if (arm_apcs_32)
558  else
560  gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
561  }
562 
563  if (regnum == ARM_PC_REGNUM || regnum == -1)
564  regcache_raw_collect (regcache, ARM_PC_REGNUM,
565  gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
566 }
567 
568 /* Support for register format used by the NWFPE FPA emulator. */
569 
570 #define typeNone 0x00
571 #define typeSingle 0x01
572 #define typeDouble 0x02
573 #define typeExtended 0x03
574 
575 void
577  const gdb_byte *regs)
578 {
579  const gdb_byte *reg_data;
580  gdb_byte reg_tag;
582 
583  reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
584  reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
585  memset (buf, 0, FP_REGISTER_SIZE);
586 
587  switch (reg_tag)
588  {
589  case typeSingle:
590  memcpy (buf, reg_data, 4);
591  break;
592  case typeDouble:
593  memcpy (buf, reg_data + 4, 4);
594  memcpy (buf + 4, reg_data, 4);
595  break;
596  case typeExtended:
597  /* We want sign and exponent, then least significant bits,
598  then most significant. NWFPE does sign, most, least. */
599  memcpy (buf, reg_data, 4);
600  memcpy (buf + 4, reg_data + 8, 4);
601  memcpy (buf + 8, reg_data + 4, 4);
602  break;
603  default:
604  break;
605  }
606 
607  regcache_raw_supply (regcache, regno, buf);
608 }
609 
610 void
611 collect_nwfpe_register (const struct regcache *regcache, int regno,
612  gdb_byte *regs)
613 {
614  gdb_byte *reg_data;
615  gdb_byte reg_tag;
617 
618  regcache_raw_collect (regcache, regno, buf);
619 
620  /* NOTE drow/2006-06-07: This code uses the tag already in the
621  register buffer. I've preserved that when moving the code
622  from the native file to the target file. But this doesn't
623  always make sense. */
624 
625  reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
626  reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
627 
628  switch (reg_tag)
629  {
630  case typeSingle:
631  memcpy (reg_data, buf, 4);
632  break;
633  case typeDouble:
634  memcpy (reg_data, buf + 4, 4);
635  memcpy (reg_data + 4, buf, 4);
636  break;
637  case typeExtended:
638  memcpy (reg_data, buf, 4);
639  memcpy (reg_data + 4, buf + 8, 4);
640  memcpy (reg_data + 8, buf + 4, 4);
641  break;
642  default:
643  break;
644  }
645 }
646 
647 void
649  struct regcache *regcache,
650  int regnum, const void *regs_buf, size_t len)
651 {
652  const gdb_byte *regs = regs_buf;
653  int regno;
654 
655  if (regnum == ARM_FPS_REGNUM || regnum == -1)
657  regs + NWFPE_FPSR_OFFSET);
658 
659  for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
660  if (regnum == -1 || regnum == regno)
661  supply_nwfpe_register (regcache, regno, regs);
662 }
663 
664 void
666  const struct regcache *regcache,
667  int regnum, void *regs_buf, size_t len)
668 {
669  gdb_byte *regs = regs_buf;
670  int regno;
671 
672  for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
673  if (regnum == -1 || regnum == regno)
674  collect_nwfpe_register (regcache, regno, regs);
675 
676  if (regnum == ARM_FPS_REGNUM || regnum == -1)
679 }
680 
681 /* Support VFP register format. */
682 
683 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
684 
685 static void
687  struct regcache *regcache,
688  int regnum, const void *regs_buf, size_t len)
689 {
690  const gdb_byte *regs = regs_buf;
691  int regno;
692 
693  if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
694  regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
695 
696  for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
697  if (regnum == -1 || regnum == regno)
698  regcache_raw_supply (regcache, regno,
699  regs + (regno - ARM_D0_REGNUM) * 8);
700 }
701 
702 static void
704  const struct regcache *regcache,
705  int regnum, void *regs_buf, size_t len)
706 {
707  gdb_byte *regs = regs_buf;
708  int regno;
709 
710  if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
711  regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
712 
713  for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
714  if (regnum == -1 || regnum == regno)
715  regcache_raw_collect (regcache, regno,
716  regs + (regno - ARM_D0_REGNUM) * 8);
717 }
718 
719 static const struct regset arm_linux_gregset =
720  {
722  };
723 
724 static const struct regset arm_linux_fpregset =
725  {
727  };
728 
729 static const struct regset arm_linux_vfpregset =
730  {
732  };
733 
734 /* Iterate over core file register note sections. */
735 
736 static void
739  void *cb_data,
740  const struct regcache *regcache)
741 {
742  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
743 
744  cb (".reg", ARM_LINUX_SIZEOF_GREGSET, &arm_linux_gregset, NULL, cb_data);
745 
746  if (tdep->vfp_register_count > 0)
747  cb (".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP, &arm_linux_vfpregset,
748  "VFP floating-point", cb_data);
749  else if (tdep->have_fpa_registers)
750  cb (".reg2", ARM_LINUX_SIZEOF_NWFPE, &arm_linux_fpregset,
751  "FPA floating-point", cb_data);
752 }
753 
754 /* Determine target description from core file. */
755 
756 static const struct target_desc *
758  struct target_ops *target,
759  bfd *abfd)
760 {
761  CORE_ADDR arm_hwcap = 0;
762 
763  if (target_auxv_search (target, AT_HWCAP, &arm_hwcap) != 1)
764  return NULL;
765 
766  if (arm_hwcap & HWCAP_VFP)
767  {
768  /* NEON implies VFPv3-D32 or no-VFP unit. Say that we only support
769  Neon with VFPv3-D32. */
770  if (arm_hwcap & HWCAP_NEON)
771  return tdesc_arm_with_neon;
772  else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
773  return tdesc_arm_with_vfpv3;
774  else
775  return tdesc_arm_with_vfpv2;
776  }
777 
778  return NULL;
779 }
780 
781 
782 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
783  return 1. In addition, set IS_THUMB depending on whether we
784  will return to ARM or Thumb code. Return 0 if it is not a
785  rt_sigreturn/sigreturn syscall. */
786 static int
788  unsigned long svc_number,
789  CORE_ADDR *pc, int *is_thumb)
790 {
791  /* Is this a sigreturn or rt_sigreturn syscall? */
792  if (svc_number == 119 || svc_number == 173)
793  {
794  if (get_frame_type (frame) == SIGTRAMP_FRAME)
795  {
796  ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame));
797  CORE_ADDR cpsr
799 
800  *is_thumb = (cpsr & t_bit) != 0;
801  *pc = frame_unwind_caller_pc (frame);
802  return 1;
803  }
804  }
805  return 0;
806 }
807 
808 /* At a ptrace syscall-stop, return the syscall number. This either
809  comes from the SWI instruction (OABI) or from r7 (EABI).
810 
811  When the function fails, it should return -1. */
812 
813 static LONGEST
815  ptid_t ptid)
816 {
817  struct regcache *regs = get_thread_regcache (ptid);
818  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
819 
820  ULONGEST pc;
821  ULONGEST cpsr;
822  ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
823  int is_thumb;
824  ULONGEST svc_number = -1;
825 
828  is_thumb = (cpsr & t_bit) != 0;
829 
830  if (is_thumb)
831  {
832  regcache_cooked_read_unsigned (regs, 7, &svc_number);
833  }
834  else
835  {
836  enum bfd_endian byte_order_for_code =
837  gdbarch_byte_order_for_code (gdbarch);
838 
839  /* PC gets incremented before the syscall-stop, so read the
840  previous instruction. */
841  unsigned long this_instr =
842  read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);
843 
844  unsigned long svc_operand = (0x00ffffff & this_instr);
845 
846  if (svc_operand)
847  {
848  /* OABI */
849  svc_number = svc_operand - 0x900000;
850  }
851  else
852  {
853  /* EABI */
854  regcache_cooked_read_unsigned (regs, 7, &svc_number);
855  }
856  }
857 
858  return svc_number;
859 }
860 
861 /* When FRAME is at a syscall instruction, return the PC of the next
862  instruction to be executed. */
863 
864 static CORE_ADDR
866 {
867  CORE_ADDR pc = get_frame_pc (frame);
868  CORE_ADDR return_addr = 0;
869  int is_thumb = arm_frame_is_thumb (frame);
870  ULONGEST svc_number = 0;
871 
872  if (is_thumb)
873  {
874  svc_number = get_frame_register_unsigned (frame, 7);
875  return_addr = pc + 2;
876  }
877  else
878  {
879  struct gdbarch *gdbarch = get_frame_arch (frame);
880  enum bfd_endian byte_order_for_code =
881  gdbarch_byte_order_for_code (gdbarch);
882  unsigned long this_instr =
883  read_memory_unsigned_integer (pc, 4, byte_order_for_code);
884 
885  unsigned long svc_operand = (0x00ffffff & this_instr);
886  if (svc_operand) /* OABI. */
887  {
888  svc_number = svc_operand - 0x900000;
889  }
890  else /* EABI. */
891  {
892  svc_number = get_frame_register_unsigned (frame, 7);
893  }
894 
895  return_addr = pc + 4;
896  }
897 
898  arm_linux_sigreturn_return_addr (frame, svc_number, &return_addr, &is_thumb);
899 
900  /* Addresses for calling Thumb functions have the bit 0 set. */
901  if (is_thumb)
902  return_addr |= 1;
903 
904  return return_addr;
905 }
906 
907 
908 /* Insert a single step breakpoint at the next executed instruction. */
909 
910 static int
912 {
913  struct gdbarch *gdbarch = get_frame_arch (frame);
914  struct address_space *aspace = get_frame_address_space (frame);
915  CORE_ADDR next_pc;
916 
917  if (arm_deal_with_atomic_sequence (frame))
918  return 1;
919 
920  next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
921 
922  /* The Linux kernel offers some user-mode helpers in a high page. We can
923  not read this page (as of 2.6.23), and even if we could then we couldn't
924  set breakpoints in it, and even if we could then the atomic operations
925  would fail when interrupted. They are all called as functions and return
926  to the address in LR, so step to there instead. */
927  if (next_pc > 0xffff0000)
928  next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
929 
930  arm_insert_single_step_breakpoint (gdbarch, aspace, next_pc);
931 
932  return 1;
933 }
934 
935 /* Support for displaced stepping of Linux SVC instructions. */
936 
937 static void
939  struct regcache *regs,
940  struct displaced_step_closure *dsc)
941 {
942  ULONGEST apparent_pc;
943  int within_scratch;
944 
945  regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
946 
947  within_scratch = (apparent_pc >= dsc->scratch_base
948  && apparent_pc < (dsc->scratch_base
949  + DISPLACED_MODIFIED_INSNS * 4 + 4));
950 
951  if (debug_displaced)
952  {
953  fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
954  "SVC step ", (unsigned long) apparent_pc);
955  if (within_scratch)
956  fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
957  else
958  fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
959  }
960 
961  if (within_scratch)
963  dsc->insn_addr + dsc->insn_size, BRANCH_WRITE_PC);
964 }
965 
966 static int
968  struct displaced_step_closure *dsc)
969 {
970  CORE_ADDR return_to = 0;
971 
972  struct frame_info *frame;
973  unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
974  int is_sigreturn = 0;
975  int is_thumb;
976 
977  frame = get_current_frame ();
978 
979  is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
980  &return_to, &is_thumb);
981  if (is_sigreturn)
982  {
983  struct symtab_and_line sal;
984 
985  if (debug_displaced)
986  fprintf_unfiltered (gdb_stdlog, "displaced: found "
987  "sigreturn/rt_sigreturn SVC call. PC in "
988  "frame = %lx\n",
989  (unsigned long) get_frame_pc (frame));
990 
991  if (debug_displaced)
992  fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
993  "Setting momentary breakpoint.\n",
994  (unsigned long) return_to);
995 
996  gdb_assert (inferior_thread ()->control.step_resume_breakpoint
997  == NULL);
998 
999  sal = find_pc_line (return_to, 0);
1000  sal.pc = return_to;
1001  sal.section = find_pc_overlay (return_to);
1002  sal.explicit_pc = 1;
1003 
1004  frame = get_prev_frame (frame);
1005 
1006  if (frame)
1007  {
1009  = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
1010  bp_step_resume);
1011 
1012  /* set_momentary_breakpoint invalidates FRAME. */
1013  frame = NULL;
1014 
1015  /* We need to make sure we actually insert the momentary
1016  breakpoint set above. */
1017  insert_breakpoints ();
1018  }
1019  else if (debug_displaced)
1020  fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
1021  "frame to set momentary breakpoint for "
1022  "sigreturn/rt_sigreturn\n");
1023  }
1024  else if (debug_displaced)
1025  fprintf_unfiltered (gdb_stdlog, "displaced: found SVC call\n");
1026 
1027  /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1028  location, else nothing.
1029  Insn: unmodified svc.
1030  Cleanup: if pc lands in scratch space, pc <- insn_addr + insn_size
1031  else leave pc alone. */
1032 
1033 
1035  /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1036  instruction. */
1037  dsc->wrote_to_pc = 1;
1038 
1039  return 0;
1040 }
1041 
1042 
1043 /* The following two functions implement single-stepping over calls to Linux
1044  kernel helper routines, which perform e.g. atomic operations on architecture
1045  variants which don't support them natively.
1046 
1047  When this function is called, the PC will be pointing at the kernel helper
1048  (at an address inaccessible to GDB), and r14 will point to the return
1049  address. Displaced stepping always executes code in the copy area:
1050  so, make the copy-area instruction branch back to the kernel helper (the
1051  "from" address), and make r14 point to the breakpoint in the copy area. In
1052  that way, we regain control once the kernel helper returns, and can clean
1053  up appropriately (as if we had just returned from the kernel helper as it
1054  would have been called from the non-displaced location). */
1055 
1056 static void
1058  struct regcache *regs,
1059  struct displaced_step_closure *dsc)
1060 {
1061  displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
1062  displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
1063 }
1064 
1065 static void
1067  CORE_ADDR to, struct regcache *regs,
1068  struct displaced_step_closure *dsc)
1069 {
1070  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1071 
1072  dsc->numinsns = 1;
1073  dsc->insn_addr = from;
1075  /* Say we wrote to the PC, else cleanup will set PC to the next
1076  instruction in the helper, which isn't helpful. */
1077  dsc->wrote_to_pc = 1;
1078 
1079  /* Preparation: tmp[0] <- r14
1080  r14 <- <scratch space>+4
1081  *(<scratch space>+8) <- from
1082  Insn: ldr pc, [r14, #4]
1083  Cleanup: r14 <- tmp[0], pc <- tmp[0]. */
1084 
1085  dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM);
1086  displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
1087  CANNOT_WRITE_PC);
1088  write_memory_unsigned_integer (to + 8, 4, byte_order, from);
1089 
1090  dsc->modinsn[0] = 0xe59ef004; /* ldr pc, [lr, #4]. */
1091 }
1092 
1093 /* Linux-specific displaced step instruction copying function. Detects when
1094  the program has stepped into a Linux kernel helper routine (which must be
1095  handled as a special case), falling back to arm_displaced_step_copy_insn()
1096  if it hasn't. */
1097 
1098 static struct displaced_step_closure *
1101  struct regcache *regs)
1102 {
1103  struct displaced_step_closure *dsc
1104  = xmalloc (sizeof (struct displaced_step_closure));
1105 
1106  /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1107  stop at the return location. */
1108  if (from > 0xffff0000)
1109  {
1110  if (debug_displaced)
1111  fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
1112  "at %.8lx\n", (unsigned long) from);
1113 
1114  arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
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);
1122  }
1123 
1124  arm_displaced_init_closure (gdbarch, from, to, dsc);
1125 
1126  return dsc;
1127 }
1128 
1129 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1130  gdbarch.h. */
1131 
1132 static int
1134 {
1135  return (*s == '#' || *s == '$' || isdigit (*s) /* Literal number. */
1136  || *s == '[' /* Register indirection or
1137  displacement. */
1138  || isalpha (*s)); /* Register value. */
1139 }
1140 
1141 /* This routine is used to parse a special token in ARM's assembly.
1142 
1143  The special tokens parsed by it are:
1144 
1145  - Register displacement (e.g, [fp, #-8])
1146 
1147  It returns one if the special token has been parsed successfully,
1148  or zero if the current token is not considered special. */
1149 
1150 static int
1152  struct stap_parse_info *p)
1153 {
1154  if (*p->arg == '[')
1155  {
1156  /* Temporary holder for lookahead. */
1157  const char *tmp = p->arg;
1158  char *endp;
1159  /* Used to save the register name. */
1160  const char *start;
1161  char *regname;
1162  int len, offset;
1163  int got_minus = 0;
1164  long displacement;
1165  struct stoken str;
1166 
1167  ++tmp;
1168  start = tmp;
1169 
1170  /* Register name. */
1171  while (isalnum (*tmp))
1172  ++tmp;
1173 
1174  if (*tmp != ',')
1175  return 0;
1176 
1177  len = tmp - start;
1178  regname = 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_const (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 0;
1217 
1218  /* The displacement. */
1219  write_exp_elt_opcode (&p->pstate, OP_LONG);
1220  write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
1221  write_exp_elt_longcst (&p->pstate, displacement);
1222  write_exp_elt_opcode (&p->pstate, OP_LONG);
1223  if (got_minus)
1224  write_exp_elt_opcode (&p->pstate, UNOP_NEG);
1225 
1226  /* The register name. */
1227  write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1228  str.ptr = regname;
1229  str.length = len;
1230  write_exp_string (&p->pstate, str);
1231  write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1232 
1233  write_exp_elt_opcode (&p->pstate, BINOP_ADD);
1234 
1235  /* Casting to the expected type. */
1236  write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1238  write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1239 
1240  write_exp_elt_opcode (&p->pstate, UNOP_IND);
1241 
1242  p->arg = tmp;
1243  }
1244  else
1245  return 0;
1246 
1247  return 1;
1248 }
1249 
1250 /* ARM process record-replay constructs: syscall, signal etc. */
1251 
1253 
1254 /* arm_canonicalize_syscall maps from the native arm Linux set
1255  of syscall ids into a canonical set of syscall ids used by
1256  process record. */
1257 
1258 static enum gdb_syscall
1260 {
1261  enum { sys_process_vm_writev = 377 };
1262 
1263  if (syscall <= gdb_sys_sched_getaffinity)
1264  return syscall;
1265  else if (syscall >= 243 && syscall <= 247)
1266  return syscall + 2;
1267  else if (syscall >= 248 && syscall <= 253)
1268  return syscall + 4;
1269 
1270  return -1;
1271 }
1272 
1273 /* Record all registers but PC register for process-record. */
1274 
1275 static int
1277 {
1278  int i;
1279 
1280  for (i = 0; i < ARM_PC_REGNUM; i++)
1281  {
1282  if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i))
1283  return -1;
1284  }
1285 
1287  return -1;
1288 
1289  return 0;
1290 }
1291 
1292 /* Handler for arm system call instruction recording. */
1293 
1294 static int
1295 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number)
1296 {
1297  int ret = 0;
1298  enum gdb_syscall syscall_gdb;
1299 
1300  syscall_gdb = arm_canonicalize_syscall (svc_number);
1301 
1302  if (syscall_gdb < 0)
1303  {
1304  printf_unfiltered (_("Process record and replay target doesn't "
1305  "support syscall number %s\n"),
1306  plongest (svc_number));
1307  return -1;
1308  }
1309 
1310  if (syscall_gdb == gdb_sys_sigreturn
1311  || syscall_gdb == gdb_sys_rt_sigreturn)
1312  {
1313  if (arm_all_but_pc_registers_record (regcache))
1314  return -1;
1315  return 0;
1316  }
1317 
1318  ret = record_linux_system_call (syscall_gdb, regcache,
1320  if (ret != 0)
1321  return ret;
1322 
1323  /* Record the return value of the system call. */
1325  return -1;
1326  /* Record LR. */
1328  return -1;
1329  /* Record CPSR. */
1331  return -1;
1332 
1333  return 0;
1334 }
1335 
1336 /* Implement the skip_trampoline_code gdbarch method. */
1337 
1338 static CORE_ADDR
1340 {
1341  CORE_ADDR target_pc = arm_skip_stub (frame, pc);
1342 
1343  if (target_pc != 0)
1344  return target_pc;
1345 
1346  return find_solib_trampoline_target (frame, pc);
1347 }
1348 
1349 static void
1351  struct gdbarch *gdbarch)
1352 {
1353  static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL };
1354  static const char *const stap_register_prefixes[] = { "r", NULL };
1355  static const char *const stap_register_indirection_prefixes[] = { "[",
1356  NULL };
1357  static const char *const stap_register_indirection_suffixes[] = { "]",
1358  NULL };
1359  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1360 
1361  linux_init_abi (info, gdbarch);
1362 
1363  tdep->lowest_pc = 0x8000;
1364  if (info.byte_order_for_code == BFD_ENDIAN_BIG)
1365  {
1366  if (tdep->arm_abi == ARM_ABI_AAPCS)
1368  else
1372  }
1373  else
1374  {
1375  if (tdep->arm_abi == ARM_ABI_AAPCS)
1377  else
1381  }
1385 
1386  if (tdep->fp_model == ARM_FLOAT_AUTO)
1387  tdep->fp_model = ARM_FLOAT_FPA;
1388 
1389  switch (tdep->fp_model)
1390  {
1391  case ARM_FLOAT_FPA:
1392  tdep->jb_pc = ARM_LINUX_JB_PC_FPA;
1393  break;
1394  case ARM_FLOAT_SOFT_FPA:
1395  case ARM_FLOAT_SOFT_VFP:
1396  case ARM_FLOAT_VFP:
1397  tdep->jb_pc = ARM_LINUX_JB_PC_EABI;
1398  break;
1399  default:
1401  (__FILE__, __LINE__,
1402  _("arm_linux_init_abi: Floating point model not supported"));
1403  break;
1404  }
1406 
1409 
1410  /* Single stepping. */
1412 
1413  /* Shared library handling. */
1416 
1417  /* Enable TLS support. */
1420 
1422  &arm_linux_sigreturn_tramp_frame);
1424  &arm_linux_rt_sigreturn_tramp_frame);
1426  &arm_eabi_linux_sigreturn_tramp_frame);
1428  &arm_eabi_linux_rt_sigreturn_tramp_frame);
1430  &thumb2_eabi_linux_sigreturn_tramp_frame);
1432  &thumb2_eabi_linux_rt_sigreturn_tramp_frame);
1434  &arm_linux_restart_syscall_tramp_frame);
1436  &arm_kernel_linux_restart_syscall_tramp_frame);
1437 
1438  /* Core file support. */
1442 
1443  /* Displaced stepping. */
1450 
1451  /* Reversible debugging, process record. */
1453 
1454  /* SystemTap functions. */
1455  set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1456  set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1458  stap_register_indirection_prefixes);
1460  stap_register_indirection_suffixes);
1461  set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
1465 
1467 
1468  /* `catch syscall' */
1469  set_xml_syscall_file_name (gdbarch, "syscalls/arm-linux.xml");
1471 
1472  /* Syscall record. */
1474 
1475  /* Initialize the arm_linux_record_tdep. */
1476  /* These values are the size of the type that will be used in a system
1477  call. They are obtained from Linux Kernel source. */
1479  = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1501  = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1503  = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1505  = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1551 
1552  /* These values are the second argument of system call "sys_ioctl".
1553  They are obtained from Linux Kernel source. */
1596  arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1597  arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1619 
1620  /* These values are the second argument of system call "sys_fcntl"
1621  and "sys_fcntl64". They are obtained from Linux Kernel source. */
1626 
1631 }
1632 
1633 /* Provide a prototype to silence -Wmissing-prototypes. */
1635 
1636 void
1638 {
1639  gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
1641 }
static int arm_all_but_pc_registers_record(struct regcache *regcache)
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
CORE_ADDR(* syscall_next_pc)(struct frame_info *frame)
Definition: arm-tdep.h:206
static int arm_stap_parse_special_token(struct gdbarch *gdbarch, struct stap_parse_info *p)
#define ARM_OABI_SYSCALL_RESTART_SYSCALL
void trad_frame_set_reg_addr(struct trad_frame_cache *this_trad_cache, int regnum, CORE_ADDR addr)
Definition: trad-frame.c:119
int size_serial_icounter_struct
Definition: linux-record.h:90
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:554
#define ARM_LINUX_JB_ELEMENT_SIZE
void arm_linux_supply_nwfpe(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs_buf, size_t len)
void set_gdbarch_displaced_step_fixup(struct gdbarch *gdbarch, gdbarch_displaced_step_fixup_ftype displaced_step_fixup)
Definition: gdbarch.c:3709
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2217
const gdb_byte * thumb_breakpoint
Definition: arm-tdep.h:181
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
struct type * arg_type
Definition: stap-probe.h:46
Definition: target.h:98
bfd_vma CORE_ADDR
Definition: common-types.h:41
unsigned long modinsn[DISPLACED_MODIFIED_INSNS]
Definition: arm-tdep.h:282
#define ARM_NEW_RT_SIGFRAME_UCONTEXT
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:2822
#define TRAMP_SENTINEL_INSN
Definition: tramp-frame.h:44
#define THUMB2_EABI_SYSCALL
void insert_breakpoints(void)
Definition: breakpoint.c:2984
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:529
const char * ptr
Definition: parser-defs.h:79
void set_gdbarch_stap_parse_special_token(struct gdbarch *gdbarch, gdbarch_stap_parse_special_token_ftype stap_parse_special_token)
Definition: gdbarch.c:4243
unsigned int insn_size
Definition: arm-tdep.h:273
#define THUMB2_SET_R7_SIGRETURN2
struct frame_info * get_prev_frame(struct frame_info *this_frame)
Definition: frame.c:2122
int record_full_arch_list_add_reg(struct regcache *regcache, int regnum)
Definition: record-full.c:466
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
static void arm_linux_supply_vfp(const struct regset *regset, struct regcache *regcache, int regnum, const void *regs_buf, size_t len)
static CORE_ADDR arm_linux_syscall_next_pc(struct frame_info *frame)
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
Definition: corefile.c:412
CORE_ADDR frame_unwind_caller_pc(struct frame_info *this_frame)
Definition: frame.c:870
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1490
void(* func)(char *)
struct target_desc * tdesc_arm_with_vfpv2
Definition: arm-with-vfpv2.c:8
void set_gdbarch_skip_trampoline_code(struct gdbarch *gdbarch, gdbarch_skip_trampoline_code_ftype skip_trampoline_code)
Definition: gdbarch.c:3084
CORE_ADDR glibc_skip_solib_resolver(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: glibc-tdep.c:38
#define NWFPE_FPSR_OFFSET
CORE_ADDR scratch_base
Definition: arm-tdep.h:285
void set_gdbarch_displaced_step_location(struct gdbarch *gdbarch, gdbarch_displaced_step_location_ftype displaced_step_location)
Definition: gdbarch.c:3743
int gdbarch_ptr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1690
void collect_nwfpe_register(const struct regcache *regcache, int regno, gdb_byte *regs)
void trad_frame_set_id(struct trad_frame_cache *this_trad_cache, struct frame_id this_id)
Definition: trad-frame.c:164
int arm_psr_thumb_bit(struct gdbarch *gdbarch)
Definition: arm-tdep.c:283
void set_gdbarch_stap_register_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_prefixes)
Definition: gdbarch.c:4110
static int arm_linux_software_single_step(struct frame_info *frame)
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1182
int arm_frame_is_thumb(struct frame_info *frame)
Definition: arm-tdep.c:294
enum arm_float_model fp_model
Definition: arm-tdep.h:161
CORE_ADDR arm_get_next_pc(struct frame_info *frame, CORE_ADDR pc)
Definition: arm-tdep.c:5044
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
struct thread_info * inferior_thread(void)
Definition: thread.c:85
static void arm_catch_kernel_helper_return(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs, struct displaced_step_closure *dsc)
struct m32c_reg * pc
Definition: m32c-tdep.c:111
const char * arg
Definition: stap-probe.h:32
#define ARM_LINUX_JB_PC_FPA
void linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
Definition: linux-tdep.c:2427
#define ARM_NEW_SIGFRAME_MAGIC
#define THUMB2_SET_R7_SIGRETURN1
static const gdb_byte eabi_linux_arm_be_breakpoint[]
const gdb_byte * arm_breakpoint
Definition: arm-tdep.h:179
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1507
void arm_insert_single_step_breakpoint(struct gdbarch *gdbarch, struct address_space *aspace, CORE_ADDR pc)
Definition: arm-tdep.c:5061
#define ARM_CPSR_GREGNUM
int arm_deal_with_atomic_sequence(struct frame_info *frame)
Definition: arm-tdep.c:5288
struct link_map_offsets * svr4_ilp32_fetch_link_map_offsets(void)
Definition: solib-svr4.c:3149
CORE_ADDR lowest_pc
Definition: aarch64-tdep.h:76
ULONGEST tmp[DISPLACED_TEMPS]
Definition: arm-tdep.h:223
struct obj_section * section
Definition: symtab.h:1370
#define INT_REGISTER_SIZE
Definition: arm-tdep.h:67
struct address_space * get_frame_address_space(struct frame_info *frame)
Definition: frame.c:2490
#define _(String)
Definition: gdb_locale.h:40
ULONGEST get_frame_memory_unsigned(struct frame_info *this_frame, CORE_ADDR addr, int len)
Definition: frame.c:2515
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1402
static void arm_linux_sigtramp_cache(struct frame_info *this_frame, struct trad_frame_cache *this_cache, CORE_ADDR func, int regs_offset)
void set_gdbarch_process_record(struct gdbarch *gdbarch, gdbarch_process_record_ftype process_record)
Definition: gdbarch.c:3881
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
void set_gdbarch_stap_register_indirection_suffixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_suffixes)
Definition: gdbarch.c:4161
Definition: ptid.h:35
enum arm_abi_kind arm_abi
Definition: arm-tdep.h:159
static const gdb_byte eabi_linux_arm_le_breakpoint[]
struct gdbarch * frame_unwind_arch(struct frame_info *next_frame)
Definition: frame.c:2541
struct obj_section * find_pc_overlay(CORE_ADDR pc)
Definition: symfile.c:3287
void arm_displaced_init_closure(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct displaced_step_closure *dsc)
Definition: arm-tdep.c:8679
CORE_ADDR svr4_fetch_objfile_link_map(struct objfile *objfile)
Definition: solib-svr4.c:1573
Definition: regset.h:34
union displaced_step_closure::@19 u
#define typeExtended
void set_gdbarch_stap_integer_prefixes(struct gdbarch *gdbarch, const char *const *stap_integer_prefixes)
Definition: gdbarch.c:4076
void set_gdbarch_stap_gdb_register_prefix(struct gdbarch *gdbarch, const char *stap_gdb_register_prefix)
Definition: gdbarch.c:4178
struct parser_state pstate
Definition: stap-probe.h:35
#define ARM_LINUX_JB_PC_EABI
int have_fpa_registers
Definition: arm-tdep.h:163
int * from
Definition: varobj.h:282
#define ARM_LINUX_SIZEOF_VFP
void write_exp_elt_longcst(struct parser_state *ps, LONGEST expelt)
Definition: parse.c:276
enum frame_type get_frame_type(struct frame_info *frame)
Definition: frame.c:2463
int arm_process_record(struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR insn_addr)
Definition: arm-tdep.c:13918
struct frame_id get_frame_id(struct frame_info *fi)
Definition: frame.c:473
int thumb_breakpoint_size
Definition: arm-tdep.h:182
void displaced_write_reg(struct regcache *regs, struct displaced_step_closure *dsc, int regno, ULONGEST val, enum pc_write_style write_pc)
Definition: arm-tdep.c:5655
#define ARM_OLD_RT_SIGFRAME_SIGINFO
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:8752
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
void initialize_file_ftype(void)
Definition: defs.h:281
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3315
int record_linux_system_call(enum gdb_syscall syscall, struct regcache *regcache, struct linux_record_tdep *tdep)
Definition: linux-record.c:227
CORE_ADDR find_solib_trampoline_target(struct frame_info *frame, CORE_ADDR pc)
Definition: minsyms.c:1394
const char * skip_spaces_const(const char *chp)
Definition: common-utils.c:271
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
static void arm_linux_collect_vfp(const struct regset *regset, const struct regcache *regcache, int regnum, void *regs_buf, size_t len)
int arm_apcs_32
Definition: arm-tdep.c:278
void(* cleanup)(struct gdbarch *, struct regcache *, struct displaced_step_closure *)
Definition: arm-tdep.h:286
static const gdb_byte arm_linux_thumb2_be_breakpoint[]
int debug_displaced
Definition: infrun.c:132
void arm_linux_collect_gregset(const struct regset *regset, const struct regcache *regcache, int regnum, void *gregs_buf, size_t len)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
int target_auxv_search(struct target_ops *ops, CORE_ADDR match, CORE_ADDR *valp)
Definition: auxv.c:375
#define FP_REGISTER_SIZE
Definition: arm-tdep.h:72
#define NWFPE_TAGS_OFFSET
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)
#define THUMB2_SET_R7_RT_SIGRETURN2
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
void set_solib_svr4_fetch_link_map_offsets(struct gdbarch *gdbarch, struct link_map_offsets *(*flmo)(void))
Definition: solib-svr4.c:3108
void set_gdbarch_stap_register_indirection_prefixes(struct gdbarch *gdbarch, const char *const *stap_register_indirection_prefixes)
Definition: gdbarch.c:4144
struct thread_control_state control
Definition: gdbthread.h:198
void arm_process_displaced_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs, struct displaced_step_closure *dsc)
Definition: arm-tdep.c:8619
#define HWCAP_VFPv3D16
static const gdb_byte arm_linux_thumb2_le_breakpoint[]
struct linux_record_tdep arm_linux_record_tdep
#define gdb_assert(expr)
Definition: gdb_assert.h:33
const char * saved_arg
Definition: stap-probe.h:40
#define ARM_LDR_PC_SP_12
#define typeSingle
void trad_frame_set_reg_value(struct trad_frame_cache *this_trad_cache, int regnum, LONGEST val)
Definition: trad-frame.c:102
initialize_file_ftype _initialize_arm_linux_tdep
int regnum
Definition: aarch64-tdep.c:69
void set_xml_syscall_file_name(struct gdbarch *gdbarch, const char *name)
Definition: xml-syscall.c:392
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
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:98
int user_reg_map_name_to_regnum(struct gdbarch *gdbarch, const char *name, int len)
Definition: user-regs.c:129
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1194
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
CORE_ADDR linux_displaced_step_location(struct gdbarch *gdbarch)
Definition: linux-tdep.c:2384
ULONGEST displaced_read_reg(struct regcache *regs, struct displaced_step_closure *dsc, int regno)
Definition: arm-tdep.c:5535
static struct displaced_step_closure * arm_linux_displaced_step_copy_insn(struct gdbarch *gdbarch, CORE_ADDR from, CORE_ADDR to, struct regcache *regs)
struct breakpoint * set_momentary_breakpoint(struct gdbarch *gdbarch, struct symtab_and_line sal, struct frame_id frame_id, enum bptype type)
Definition: breakpoint.c:8756
size_t jb_elt_size
Definition: aarch64-tdep.h:83
gdb_syscall
Definition: linux-record.h:184
int(* arm_syscall_record)(struct regcache *regcache, unsigned long svc_number)
Definition: arm-tdep.h:209
void set_gdbarch_software_single_step(struct gdbarch *gdbarch, gdbarch_software_single_step_ftype software_single_step)
Definition: gdbarch.c:3026
void write_exp_elt_opcode(struct parser_state *ps, enum exp_opcode expelt)
Definition: parse.c:236
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)
#define HWCAP_VFP
static int arm_linux_syscall_record(struct regcache *regcache, unsigned long svc_number)
#define ARM_LINUX_SIZEOF_GREGSET
bfd_byte gdb_byte
Definition: common-types.h:38
#define typeDouble
void arm_linux_supply_gregset(const struct regset *regset, struct regcache *regcache, int regnum, const void *gregs_buf, size_t len)
#define HWCAP_NEON
void set_gdbarch_displaced_step_copy_insn(struct gdbarch *gdbarch, gdbarch_displaced_step_copy_insn_ftype displaced_step_copy_insn)
Definition: gdbarch.c:3667
const gdb_byte * thumb2_breakpoint
Definition: arm-tdep.h:188
void arm_linux_collect_nwfpe(const struct regset *regset, const struct regcache *regcache, int regnum, void *regs_buf, size_t len)
static const gdb_byte arm_linux_arm_be_breakpoint[]
struct displaced_step_closure::@19::@24 svc
int thumb2_breakpoint_size
Definition: arm-tdep.h:189
#define ARM_OLD_RT_SIGFRAME_UCONTEXT
#define ARM_SIGCONTEXT_R0
struct ui_file * gdb_stderr
Definition: main.c:72
static LONGEST arm_linux_get_syscall_number(struct gdbarch *gdbarch, ptid_t ptid)
void supply_nwfpe_register(struct regcache *regcache, int regno, const gdb_byte *regs)
void set_gdbarch_stap_is_single_operand(struct gdbarch *gdbarch, gdbarch_stap_is_single_operand_ftype stap_is_single_operand)
Definition: gdbarch.c:4219
static const gdb_byte arm_linux_thumb_le_breakpoint[]
#define ARM_SET_R7_SIGRETURN
#define THUMB2_SET_R7_RT_SIGRETURN1
static int arm_linux_sigreturn_return_addr(struct frame_info *frame, unsigned long svc_number, CORE_ADDR *pc, int *is_thumb)
#define ARM_LINUX_SIGRETURN_INSTR
#define ARM_LDR_PC_SP_4
int offset
Definition: agent.c:65
void set_gdbarch_get_syscall_number(struct gdbarch *gdbarch, gdbarch_get_syscall_number_ftype get_syscall_number)
Definition: gdbarch.c:4025
void tramp_frame_prepend_unwinder(struct gdbarch *gdbarch, const struct tramp_frame *tramp_frame)
Definition: tramp-frame.c:145
int vfp_register_count
Definition: arm-tdep.h:167
static int arm_stap_is_single_operand(struct gdbarch *gdbarch, const char *s)
CORE_ADDR pc
Definition: symtab.h:1376
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)
#define HWCAP_VFPv3
struct m32c_reg * sp
Definition: m32c-tdep.c:114
static void cleanup_kernel_helper_return(struct gdbarch *gdbarch, struct regcache *regs, struct displaced_step_closure *dsc)
enum bfd_endian byte_order_for_code
Definition: gdbarch.c:129
#define ARM_UCONTEXT_SIGCONTEXT
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
static const gdb_byte arm_linux_thumb_be_breakpoint[]
unsigned long long ULONGEST
Definition: common-types.h:53
static enum gdb_syscall arm_canonicalize_syscall(int syscall)
enum bfd_endian byte_order_for_code
Definition: gdbarch.h:1554
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
void set_gdbarch_displaced_step_free_closure(struct gdbarch *gdbarch, gdbarch_displaced_step_free_closure_ftype displaced_step_free_closure)
Definition: gdbarch.c:3726
#define ARM_SET_R7_RT_SIGRETURN
int int * to
Definition: varobj.h:282
struct breakpoint * step_resume_breakpoint
Definition: gdbthread.h:51
static void arm_linux_cleanup_svc(struct gdbarch *gdbarch, struct regcache *regs, struct displaced_step_closure *dsc)
static void arm_linux_iterate_over_regset_sections(struct gdbarch *gdbarch, iterate_over_regset_sections_cb *cb, void *cb_data, const struct regcache *regcache)
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:321
void set_gdbarch_iterate_over_regset_sections(struct gdbarch *gdbarch, gdbarch_iterate_over_regset_sections_ftype iterate_over_regset_sections)
Definition: gdbarch.c:3398
static void arm_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
#define ARM_LINUX_RT_SIGRETURN_INSTR
#define DISPLACED_MODIFIED_INSNS
Definition: arm-tdep.h:219
void set_gdbarch_skip_solib_resolver(struct gdbarch *gdbarch, gdbarch_skip_solib_resolver_ftype skip_solib_resolver)
Definition: gdbarch.c:3101
enum bfd_endian byte_order
Definition: gdbarch.c:128
enum bfd_endian gdbarch_byte_order_for_code(struct gdbarch *gdbarch)
Definition: gdbarch.c:1429
struct target_desc * tdesc_arm_with_vfpv3
Definition: arm-with-vfpv3.c:8
void write_exp_string(struct parser_state *ps, struct stoken str)
Definition: parse.c:349
void set_gdbarch_core_read_description(struct gdbarch *gdbarch, gdbarch_core_read_description_ftype core_read_description)
Definition: gdbarch.c:3816
void write_exp_elt_type(struct parser_state *ps, struct type *expelt)
Definition: parse.c:308
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:148
void error(const char *fmt,...)
Definition: errors.c:38
static int arm_linux_copy_svc(struct gdbarch *gdbarch, struct regcache *regs, struct displaced_step_closure *dsc)
#define ARM_EABI_SYSCALL
CORE_ADDR arm_skip_stub(struct frame_info *frame, CORE_ADDR pc)
Definition: arm-tdep.c:9295
#define ARM_LINUX_SIZEOF_NWFPE
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:368
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
static const struct target_desc * arm_linux_core_read_description(struct gdbarch *gdbarch, struct target_ops *target, bfd *abfd)
int arm_breakpoint_size
Definition: arm-tdep.h:180
long long LONGEST
Definition: common-types.h:52
static const gdb_byte arm_linux_arm_le_breakpoint[]
int length
Definition: parser-defs.h:81
struct target_desc * tdesc_arm_with_neon
Definition: arm-with-neon.c:8
const ULONGEST const LONGEST len
Definition: target.h:309
void simple_displaced_step_free_closure(struct gdbarch *gdbarch, struct displaced_step_closure *closure)
Definition: arch-utils.c:64
static CORE_ADDR arm_linux_skip_trampoline_code(struct frame_info *frame, CORE_ADDR pc)