]> Git Repo - binutils.git/blob - gdb/arm-linux-tdep.c
gdb: remove SYMBOL_CLASS macro, add getter
[binutils.git] / gdb / arm-linux-tdep.c
1 /* GNU/Linux on ARM target support.
2
3    Copyright (C) 1999-2022 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"
39 #include "arch/arm-get-next-pcs.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 exection
64    of the software interrupt the kernel stops the inferior with a
65    SIGTRAP, and wakes the debugger.  */
66
67 static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
68
69 static 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
77 static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
78
79 static 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
84 static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
85
86 static 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
92 static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };
93
94 static 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
267 static CORE_ADDR
268   arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self);
269
270 /* Operation function pointers for get_next_pcs.  */
271 static struct arm_get_next_pcs_ops arm_linux_get_next_pcs_ops = {
272   arm_get_next_pcs_read_memory_unsigned_integer,
273   arm_linux_get_next_pcs_syscall_next_pc,
274   arm_get_next_pcs_addr_bits_remove,
275   arm_get_next_pcs_is_thumb,
276   arm_linux_get_next_pcs_fixup,
277 };
278
279 static void
280 arm_linux_sigtramp_cache (struct frame_info *this_frame,
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.  */
301 static void
302 arm_linux_sigreturn_init (const struct tramp_frame *self,
303                           struct frame_info *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,
314                               ARM_UCONTEXT_SIGCONTEXT
315                               + ARM_SIGCONTEXT_R0);
316   else
317     arm_linux_sigtramp_cache (this_frame, this_cache, func,
318                               ARM_SIGCONTEXT_R0);
319 }
320
321 static void
322 arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
323                           struct frame_info *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,
334                               ARM_OLD_RT_SIGFRAME_UCONTEXT
335                               + ARM_UCONTEXT_SIGCONTEXT
336                               + ARM_SIGCONTEXT_R0);
337   else
338     arm_linux_sigtramp_cache (this_frame, this_cache, func,
339                               ARM_NEW_RT_SIGFRAME_UCONTEXT
340                               + ARM_UCONTEXT_SIGCONTEXT
341                               + ARM_SIGCONTEXT_R0);
342 }
343
344 static void
345 arm_linux_restart_syscall_init (const struct tramp_frame *self,
346                                 struct frame_info *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.  */
374   pc = gdbarch_addr_bits_remove (gdbarch, 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
385 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
386   SIGTRAMP_FRAME,
387   4,
388   {
389     { ARM_LINUX_SIGRETURN_INSTR, ULONGEST_MAX },
390     { TRAMP_SENTINEL_INSN }
391   },
392   arm_linux_sigreturn_init
393 };
394
395 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
396   SIGTRAMP_FRAME,
397   4,
398   {
399     { ARM_LINUX_RT_SIGRETURN_INSTR, ULONGEST_MAX },
400     { TRAMP_SENTINEL_INSN }
401   },
402   arm_linux_rt_sigreturn_init
403 };
404
405 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
406   SIGTRAMP_FRAME,
407   4,
408   {
409     { ARM_SET_R7_SIGRETURN, ULONGEST_MAX },
410     { ARM_EABI_SYSCALL, ULONGEST_MAX },
411     { TRAMP_SENTINEL_INSN }
412   },
413   arm_linux_sigreturn_init
414 };
415
416 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
417   SIGTRAMP_FRAME,
418   4,
419   {
420     { ARM_SET_R7_RT_SIGRETURN, ULONGEST_MAX },
421     { ARM_EABI_SYSCALL, ULONGEST_MAX },
422     { TRAMP_SENTINEL_INSN }
423   },
424   arm_linux_rt_sigreturn_init
425 };
426
427 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = {
428   SIGTRAMP_FRAME,
429   2,
430   {
431     { THUMB2_SET_R7_SIGRETURN1, ULONGEST_MAX },
432     { THUMB2_SET_R7_SIGRETURN2, ULONGEST_MAX },
433     { THUMB2_EABI_SYSCALL, ULONGEST_MAX },
434     { TRAMP_SENTINEL_INSN }
435   },
436   arm_linux_sigreturn_init
437 };
438
439 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = {
440   SIGTRAMP_FRAME,
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 },
446     { TRAMP_SENTINEL_INSN }
447   },
448   arm_linux_rt_sigreturn_init
449 };
450
451 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
452   NORMAL_FRAME,
453   4,
454   {
455     { ARM_OABI_SYSCALL_RESTART_SYSCALL, ULONGEST_MAX },
456     { ARM_LDR_PC_SP_12, ULONGEST_MAX },
457     { TRAMP_SENTINEL_INSN }
458   },
459   arm_linux_restart_syscall_init
460 };
461
462 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
463   NORMAL_FRAME,
464   4,
465   {
466     { ARM_OABI_SYSCALL_RESTART_SYSCALL, ULONGEST_MAX },
467     { ARM_LDR_PC_SP_4, ULONGEST_MAX },
468     { TRAMP_SENTINEL_INSN }
469   },
470   arm_linux_restart_syscall_init
471 };
472
473 /* Core file and register set support.  */
474
475 #define ARM_LINUX_SIZEOF_GREGSET (18 * ARM_INT_REGISTER_SIZE)
476
477 void
478 arm_linux_supply_gregset (const struct regset *regset,
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)
496         regcache->raw_supply (ARM_PS_REGNUM,
497                               gregs + ARM_INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
498       else
499         regcache->raw_supply (ARM_PS_REGNUM,
500                              gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM);
501     }
502
503   if (regnum == ARM_PC_REGNUM || regnum == -1)
504     {
505       reg_pc = extract_unsigned_integer (
506                  gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM,
507                  ARM_INT_REGISTER_SIZE, byte_order);
508       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
509       store_unsigned_integer (pc_buf, ARM_INT_REGISTER_SIZE, byte_order,
510                               reg_pc);
511       regcache->raw_supply (ARM_PC_REGNUM, pc_buf);
512     }
513 }
514
515 void
516 arm_linux_collect_gregset (const struct regset *regset,
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)
531         regcache->raw_collect (ARM_PS_REGNUM,
532                               gregs + ARM_INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
533       else
534         regcache->raw_collect (ARM_PS_REGNUM,
535                               gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM);
536     }
537
538   if (regnum == ARM_PC_REGNUM || regnum == -1)
539     regcache->raw_collect (ARM_PC_REGNUM,
540                            gregs + ARM_INT_REGISTER_SIZE * ARM_PC_REGNUM);
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
550 void
551 supply_nwfpe_register (struct regcache *regcache, int regno,
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
585 void
586 collect_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
622 void
623 arm_linux_supply_nwfpe (const struct regset *regset,
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)
631     regcache->raw_supply (ARM_FPS_REGNUM,
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
639 void
640 arm_linux_collect_nwfpe (const struct regset *regset,
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)
652     regcache->raw_collect (ARM_FPS_REGNUM,
653                            regs + ARM_INT_REGISTER_SIZE * ARM_FPS_REGNUM);
654 }
655
656 /* Support VFP register format.  */
657
658 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
659
660 static void
661 arm_linux_supply_vfp (const struct regset *regset,
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
676 static void
677 arm_linux_collect_vfp (const struct regset *regset,
678                          const struct regcache *regcache,
679                          int regnum, void *regs_buf, size_t len)
680 {
681   gdb_byte *regs = (gdb_byte *) regs_buf;
682   int regno;
683
684   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
685     regcache->raw_collect (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
692 static const struct regset arm_linux_gregset =
693   {
694     NULL, arm_linux_supply_gregset, arm_linux_collect_gregset
695   };
696
697 static const struct regset arm_linux_fpregset =
698   {
699     NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe
700   };
701
702 static const struct regset arm_linux_vfpregset =
703   {
704     NULL, arm_linux_supply_vfp, arm_linux_collect_vfp
705   };
706
707 /* Iterate over core file register note sections.  */
708
709 static void
710 arm_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
711                                         iterate_over_regset_sections_cb *cb,
712                                         void *cb_data,
713                                         const struct regcache *regcache)
714 {
715   arm_gdbarch_tdep *tdep = (arm_gdbarch_tdep *) gdbarch_tdep (gdbarch);
716
717   cb (".reg", ARM_LINUX_SIZEOF_GREGSET, ARM_LINUX_SIZEOF_GREGSET,
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)
724     cb (".reg2", ARM_LINUX_SIZEOF_NWFPE, ARM_LINUX_SIZEOF_NWFPE,
725         &arm_linux_fpregset, "FPA floating-point", cb_data);
726 }
727
728 /* Determine target description from core file.  */
729
730 static const struct target_desc *
731 arm_linux_core_read_description (struct gdbarch *gdbarch,
732                                  struct target_ops *target,
733                                  bfd *abfd)
734 {
735   CORE_ADDR arm_hwcap = linux_get_hwcap (target);
736
737   if (arm_hwcap & HWCAP_VFP)
738     {
739       /* NEON implies VFPv3-D32 or no-VFP unit.  Say that we only support
740          Neon with VFPv3-D32.  */
741       if (arm_hwcap & HWCAP_NEON)
742         return aarch32_read_description ();
743       else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
744         return arm_read_description (ARM_FP_TYPE_VFPV3);
745
746       return arm_read_description (ARM_FP_TYPE_VFPV2);
747     }
748
749   return nullptr;
750 }
751
752
753 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
754    return 1.  In addition, set IS_THUMB depending on whether we
755    will return to ARM or Thumb code.  Return 0 if it is not a
756    rt_sigreturn/sigreturn syscall.  */
757 static int
758 arm_linux_sigreturn_return_addr (struct frame_info *frame,
759                                  unsigned long svc_number,
760                                  CORE_ADDR *pc, int *is_thumb)
761 {
762   /* Is this a sigreturn or rt_sigreturn syscall?  */
763   if (svc_number == 119 || svc_number == 173)
764     {
765       if (get_frame_type (frame) == SIGTRAMP_FRAME)
766         {
767           ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame));
768           CORE_ADDR cpsr
769             = frame_unwind_register_unsigned (frame, ARM_PS_REGNUM);
770
771           *is_thumb = (cpsr & t_bit) != 0;
772           *pc = frame_unwind_caller_pc (frame);
773           return 1;
774         }
775     }
776   return 0;
777 }
778
779 /* Find the value of the next PC after a sigreturn or rt_sigreturn syscall
780    based on current processor state.  In addition, set IS_THUMB depending
781    on whether we will return to ARM or Thumb code.  */
782
783 static CORE_ADDR
784 arm_linux_sigreturn_next_pc (struct regcache *regcache,
785                              unsigned long svc_number, int *is_thumb)
786 {
787   ULONGEST sp;
788   unsigned long sp_data;
789   CORE_ADDR next_pc = 0;
790   struct gdbarch *gdbarch = regcache->arch ();
791   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
792   int pc_offset = 0;
793   int is_sigreturn = 0;
794   CORE_ADDR cpsr;
795
796   gdb_assert (svc_number == ARM_SIGRETURN
797               || svc_number == ARM_RT_SIGRETURN);
798
799   is_sigreturn = (svc_number == ARM_SIGRETURN);
800   regcache_cooked_read_unsigned (regcache, ARM_SP_REGNUM, &sp);
801   sp_data = read_memory_unsigned_integer (sp, 4, byte_order);
802
803   pc_offset = arm_linux_sigreturn_next_pc_offset (sp, sp_data, svc_number,
804                                                   is_sigreturn);
805
806   next_pc = read_memory_unsigned_integer (sp + pc_offset, 4, byte_order);
807
808   /* Set IS_THUMB according the CPSR saved on the stack.  */
809   cpsr = read_memory_unsigned_integer (sp + pc_offset + 4, 4, byte_order);
810   *is_thumb = ((cpsr & arm_psr_thumb_bit (gdbarch)) != 0);
811
812   return next_pc;
813 }
814
815 /* At a ptrace syscall-stop, return the syscall number.  This either
816    comes from the SWI instruction (OABI) or from r7 (EABI).
817
818    When the function fails, it should return -1.  */
819
820 static LONGEST
821 arm_linux_get_syscall_number (struct gdbarch *gdbarch,
822                               thread_info *thread)
823 {
824   struct regcache *regs = get_thread_regcache (thread);
825
826   ULONGEST pc;
827   ULONGEST cpsr;
828   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
829   int is_thumb;
830   ULONGEST svc_number = -1;
831
832   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc);
833   regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr);
834   is_thumb = (cpsr & t_bit) != 0;
835
836   if (is_thumb)
837     {
838       regcache_cooked_read_unsigned (regs, 7, &svc_number);
839     }
840   else
841     {
842       enum bfd_endian byte_order_for_code = 
843         gdbarch_byte_order_for_code (gdbarch);
844
845       /* PC gets incremented before the syscall-stop, so read the
846          previous instruction.  */
847       unsigned long this_instr = 
848         read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);
849
850       unsigned long svc_operand = (0x00ffffff & this_instr);
851
852       if (svc_operand)
853         {
854           /* OABI */
855           svc_number = svc_operand - 0x900000;
856         }
857       else
858         {
859           /* EABI */
860           regcache_cooked_read_unsigned (regs, 7, &svc_number);
861         }
862     }
863
864   return svc_number;
865 }
866
867 static CORE_ADDR
868 arm_linux_get_next_pcs_syscall_next_pc (struct arm_get_next_pcs *self)
869 {
870   CORE_ADDR next_pc = 0;
871   CORE_ADDR pc = regcache_read_pc (self->regcache);
872   int is_thumb = arm_is_thumb (self->regcache);
873   ULONGEST svc_number = 0;
874
875   if (is_thumb)
876     {
877       svc_number = regcache_raw_get_unsigned (self->regcache, 7);
878       next_pc = pc + 2;
879     }
880   else
881     {
882       struct gdbarch *gdbarch = self->regcache->arch ();
883       enum bfd_endian byte_order_for_code = 
884         gdbarch_byte_order_for_code (gdbarch);
885       unsigned long this_instr = 
886         read_memory_unsigned_integer (pc, 4, byte_order_for_code);
887
888       unsigned long svc_operand = (0x00ffffff & this_instr);
889       if (svc_operand)  /* OABI.  */
890         {
891           svc_number = svc_operand - 0x900000;
892         }
893       else /* EABI.  */
894         {
895           svc_number = regcache_raw_get_unsigned (self->regcache, 7);
896         }
897
898       next_pc = pc + 4;
899     }
900
901   if (svc_number == ARM_SIGRETURN || svc_number == ARM_RT_SIGRETURN)
902     {
903       /* SIGRETURN or RT_SIGRETURN may affect the arm thumb mode, so
904          update IS_THUMB.   */
905       next_pc = arm_linux_sigreturn_next_pc (self->regcache, svc_number,
906                                              &is_thumb);
907     }
908
909   /* Addresses for calling Thumb functions have the bit 0 set.  */
910   if (is_thumb)
911     next_pc = MAKE_THUMB_ADDR (next_pc);
912
913   return next_pc;
914 }
915
916
917 /* Insert a single step breakpoint at the next executed instruction.  */
918
919 static std::vector<CORE_ADDR>
920 arm_linux_software_single_step (struct regcache *regcache)
921 {
922   struct gdbarch *gdbarch = regcache->arch ();
923   struct arm_get_next_pcs next_pcs_ctx;
924
925   /* If the target does have hardware single step, GDB doesn't have
926      to bother software single step.  */
927   if (target_can_do_single_step () == 1)
928     return {};
929
930   arm_get_next_pcs_ctor (&next_pcs_ctx,
931                          &arm_linux_get_next_pcs_ops,
932                          gdbarch_byte_order (gdbarch),
933                          gdbarch_byte_order_for_code (gdbarch),
934                          1,
935                          regcache);
936
937   std::vector<CORE_ADDR> next_pcs = arm_get_next_pcs (&next_pcs_ctx);
938
939   for (CORE_ADDR &pc_ref : next_pcs)
940     pc_ref = gdbarch_addr_bits_remove (gdbarch, pc_ref);
941
942   return next_pcs;
943 }
944
945 /* Support for displaced stepping of Linux SVC instructions.  */
946
947 static void
948 arm_linux_cleanup_svc (struct gdbarch *gdbarch,
949                        struct regcache *regs,
950                        arm_displaced_step_copy_insn_closure *dsc)
951 {
952   ULONGEST apparent_pc;
953   int within_scratch;
954
955   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
956
957   within_scratch = (apparent_pc >= dsc->scratch_base
958                     && apparent_pc < (dsc->scratch_base
959                                       + ARM_DISPLACED_MODIFIED_INSNS * 4 + 4));
960
961   displaced_debug_printf ("PC is apparently %.8lx after SVC step %s",
962                           (unsigned long) apparent_pc,
963                           (within_scratch
964                            ? "(within scratch space)"
965                            : "(outside scratch space)"));
966
967   if (within_scratch)
968     displaced_write_reg (regs, dsc, ARM_PC_REGNUM,
969                          dsc->insn_addr + dsc->insn_size, BRANCH_WRITE_PC);
970 }
971
972 static int
973 arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
974                     arm_displaced_step_copy_insn_closure *dsc)
975 {
976   CORE_ADDR return_to = 0;
977
978   struct frame_info *frame;
979   unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
980   int is_sigreturn = 0;
981   int is_thumb;
982
983   frame = get_current_frame ();
984
985   is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
986                                                  &return_to, &is_thumb);
987   if (is_sigreturn)
988     {
989       struct symtab_and_line sal;
990
991       displaced_debug_printf ("found sigreturn/rt_sigreturn SVC call.  "
992                               "PC in frame = %lx",
993                               (unsigned long) get_frame_pc (frame));
994
995       displaced_debug_printf ("unwind pc = %lx.  Setting momentary breakpoint.",
996                               (unsigned long) return_to);
997
998       gdb_assert (inferior_thread ()->control.step_resume_breakpoint
999                   == NULL);
1000
1001       sal = find_pc_line (return_to, 0);
1002       sal.pc = return_to;
1003       sal.section = find_pc_overlay (return_to);
1004       sal.explicit_pc = 1;
1005
1006       frame = get_prev_frame (frame);
1007
1008       if (frame)
1009         {
1010           inferior_thread ()->control.step_resume_breakpoint
1011             = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
1012                                         bp_step_resume).release ();
1013
1014           /* set_momentary_breakpoint invalidates FRAME.  */
1015           frame = NULL;
1016
1017           /* We need to make sure we actually insert the momentary
1018              breakpoint set above.  */
1019           insert_breakpoints ();
1020         }
1021       else
1022         displaced_debug_printf ("couldn't find previous frame to set momentary "
1023                                 "breakpoint for sigreturn/rt_sigreturn");
1024     }
1025   else
1026     displaced_debug_printf ("found SVC call");
1027
1028   /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1029                   location, else nothing.
1030      Insn: unmodified svc.
1031      Cleanup: if pc lands in scratch space, pc <- insn_addr + insn_size
1032               else leave pc alone.  */
1033
1034
1035   dsc->cleanup = &arm_linux_cleanup_svc;
1036   /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1037      instruction.  */
1038   dsc->wrote_to_pc = 1;
1039
1040   return 0;
1041 }
1042
1043
1044 /* The following two functions implement single-stepping over calls to Linux
1045    kernel helper routines, which perform e.g. atomic operations on architecture
1046    variants which don't support them natively.
1047
1048    When this function is called, the PC will be pointing at the kernel helper
1049    (at an address inaccessible to GDB), and r14 will point to the return
1050    address.  Displaced stepping always executes code in the copy area:
1051    so, make the copy-area instruction branch back to the kernel helper (the
1052    "from" address), and make r14 point to the breakpoint in the copy area.  In
1053    that way, we regain control once the kernel helper returns, and can clean
1054    up appropriately (as if we had just returned from the kernel helper as it
1055    would have been called from the non-displaced location).  */
1056
1057 static void
1058 cleanup_kernel_helper_return (struct gdbarch *gdbarch,
1059                               struct regcache *regs,
1060                               arm_displaced_step_copy_insn_closure *dsc)
1061 {
1062   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
1063   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
1064 }
1065
1066 static void
1067 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
1068                                 CORE_ADDR to, struct regcache *regs,
1069                                 arm_displaced_step_copy_insn_closure *dsc)
1070 {
1071   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1072
1073   dsc->numinsns = 1;
1074   dsc->insn_addr = from;
1075   dsc->cleanup = &cleanup_kernel_helper_return;
1076   /* Say we wrote to the PC, else cleanup will set PC to the next
1077      instruction in the helper, which isn't helpful.  */
1078   dsc->wrote_to_pc = 1;
1079
1080   /* Preparation: tmp[0] <- r14
1081                   r14 <- <scratch space>+4
1082                   *(<scratch space>+8) <- from
1083      Insn: ldr pc, [r14, #4]
1084      Cleanup: r14 <- tmp[0], pc <- tmp[0].  */
1085
1086   dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM);
1087   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
1088                        CANNOT_WRITE_PC);
1089   write_memory_unsigned_integer (to + 8, 4, byte_order, from);
1090
1091   dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
1092 }
1093
1094 /* Linux-specific displaced step instruction copying function.  Detects when
1095    the program has stepped into a Linux kernel helper routine (which must be
1096    handled as a special case).  */
1097
1098 static displaced_step_copy_insn_closure_up
1099 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
1100                                     CORE_ADDR from, CORE_ADDR to,
1101                                     struct regcache *regs)
1102 {
1103   std::unique_ptr<arm_displaced_step_copy_insn_closure> dsc
1104     (new arm_displaced_step_copy_insn_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       displaced_debug_printf ("detected kernel helper at %.8lx",
1111                               (unsigned long) from);
1112
1113       arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc.get ());
1114     }
1115   else
1116     {
1117       /* Override the default handling of SVC instructions.  */
1118       dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
1119
1120       arm_process_displaced_insn (gdbarch, from, to, regs, dsc.get ());
1121     }
1122
1123   arm_displaced_init_closure (gdbarch, from, to, dsc.get ());
1124
1125   /* This is a work around for a problem with g++ 4.8.  */
1126   return displaced_step_copy_insn_closure_up (dsc.release ());
1127 }
1128
1129 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1130    gdbarch.h.  */
1131
1132 static int
1133 arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
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 expr::operation_up
1151 arm_stap_parse_special_token (struct gdbarch *gdbarch,
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
1166       ++tmp;
1167       start = tmp;
1168
1169       /* Register name.  */
1170       while (isalnum (*tmp))
1171         ++tmp;
1172
1173       if (*tmp != ',')
1174         return {};
1175
1176       len = tmp - start;
1177       regname = (char *) alloca (len + 2);
1178
1179       offset = 0;
1180       if (isdigit (*start))
1181         {
1182           /* If we are dealing with a register whose name begins with a
1183              digit, it means we should prefix the name with the letter
1184              `r', because GDB expects this name pattern.  Otherwise (e.g.,
1185              we are dealing with the register `fp'), we don't need to
1186              add such a prefix.  */
1187           regname[0] = 'r';
1188           offset = 1;
1189         }
1190
1191       strncpy (regname + offset, start, len);
1192       len += offset;
1193       regname[len] = '\0';
1194
1195       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
1196         error (_("Invalid register name `%s' on expression `%s'."),
1197                regname, p->saved_arg);
1198
1199       ++tmp;
1200       tmp = skip_spaces (tmp);
1201       if (*tmp == '#' || *tmp == '$')
1202         ++tmp;
1203
1204       if (*tmp == '-')
1205         {
1206           ++tmp;
1207           got_minus = 1;
1208         }
1209
1210       displacement = strtol (tmp, &endp, 10);
1211       tmp = endp;
1212
1213       /* Skipping last `]'.  */
1214       if (*tmp++ != ']')
1215         return {};
1216       p->arg = tmp;
1217
1218       using namespace expr;
1219
1220       /* The displacement.  */
1221       struct type *long_type = builtin_type (gdbarch)->builtin_long;
1222       if (got_minus)
1223         displacement = -displacement;
1224       operation_up disp = make_operation<long_const_operation> (long_type,
1225                                                                 displacement);
1226
1227       /* The register name.  */
1228       operation_up reg
1229         = make_operation<register_operation> (regname);
1230
1231       operation_up sum
1232         = make_operation<add_operation> (std::move (reg), std::move (disp));
1233
1234       /* Casting to the expected type.  */
1235       struct type *arg_ptr_type = lookup_pointer_type (p->arg_type);
1236       sum = make_operation<unop_cast_operation> (std::move (sum),
1237                                                  arg_ptr_type);
1238       return make_operation<unop_ind_operation> (std::move (sum));
1239     }
1240
1241   return {};
1242 }
1243
1244 /* ARM process record-replay constructs: syscall, signal etc.  */
1245
1246 static linux_record_tdep arm_linux_record_tdep;
1247
1248 /* arm_canonicalize_syscall maps from the native arm Linux set
1249    of syscall ids into a canonical set of syscall ids used by
1250    process record.  */
1251
1252 static enum gdb_syscall
1253 arm_canonicalize_syscall (int syscall)
1254 {
1255   switch (syscall)
1256     {
1257     case 0: return gdb_sys_restart_syscall;
1258     case 1: return gdb_sys_exit;
1259     case 2: return gdb_sys_fork;
1260     case 3: return gdb_sys_read;
1261     case 4: return gdb_sys_write;
1262     case 5: return gdb_sys_open;
1263     case 6: return gdb_sys_close;
1264     case 8: return gdb_sys_creat;
1265     case 9: return gdb_sys_link;
1266     case 10: return gdb_sys_unlink;
1267     case 11: return gdb_sys_execve;
1268     case 12: return gdb_sys_chdir;
1269     case 13: return gdb_sys_time;
1270     case 14: return gdb_sys_mknod;
1271     case 15: return gdb_sys_chmod;
1272     case 16: return gdb_sys_lchown16;
1273     case 19: return gdb_sys_lseek;
1274     case 20: return gdb_sys_getpid;
1275     case 21: return gdb_sys_mount;
1276     case 22: return gdb_sys_oldumount;
1277     case 23: return gdb_sys_setuid16;
1278     case 24: return gdb_sys_getuid16;
1279     case 25: return gdb_sys_stime;
1280     case 26: return gdb_sys_ptrace;
1281     case 27: return gdb_sys_alarm;
1282     case 29: return gdb_sys_pause;
1283     case 30: return gdb_sys_utime;
1284     case 33: return gdb_sys_access;
1285     case 34: return gdb_sys_nice;
1286     case 36: return gdb_sys_sync;
1287     case 37: return gdb_sys_kill;
1288     case 38: return gdb_sys_rename;
1289     case 39: return gdb_sys_mkdir;
1290     case 40: return gdb_sys_rmdir;
1291     case 41: return gdb_sys_dup;
1292     case 42: return gdb_sys_pipe;
1293     case 43: return gdb_sys_times;
1294     case 45: return gdb_sys_brk;
1295     case 46: return gdb_sys_setgid16;
1296     case 47: return gdb_sys_getgid16;
1297     case 49: return gdb_sys_geteuid16;
1298     case 50: return gdb_sys_getegid16;
1299     case 51: return gdb_sys_acct;
1300     case 52: return gdb_sys_umount;
1301     case 54: return gdb_sys_ioctl;
1302     case 55: return gdb_sys_fcntl;
1303     case 57: return gdb_sys_setpgid;
1304     case 60: return gdb_sys_umask;
1305     case 61: return gdb_sys_chroot;
1306     case 62: return gdb_sys_ustat;
1307     case 63: return gdb_sys_dup2;
1308     case 64: return gdb_sys_getppid;
1309     case 65: return gdb_sys_getpgrp;
1310     case 66: return gdb_sys_setsid;
1311     case 67: return gdb_sys_sigaction;
1312     case 70: return gdb_sys_setreuid16;
1313     case 71: return gdb_sys_setregid16;
1314     case 72: return gdb_sys_sigsuspend;
1315     case 73: return gdb_sys_sigpending;
1316     case 74: return gdb_sys_sethostname;
1317     case 75: return gdb_sys_setrlimit;
1318     case 76: return gdb_sys_getrlimit;
1319     case 77: return gdb_sys_getrusage;
1320     case 78: return gdb_sys_gettimeofday;
1321     case 79: return gdb_sys_settimeofday;
1322     case 80: return gdb_sys_getgroups16;
1323     case 81: return gdb_sys_setgroups16;
1324     case 82: return gdb_sys_select;
1325     case 83: return gdb_sys_symlink;
1326     case 85: return gdb_sys_readlink;
1327     case 86: return gdb_sys_uselib;
1328     case 87: return gdb_sys_swapon;
1329     case 88: return gdb_sys_reboot;
1330     case 89: return gdb_old_readdir;
1331     case 90: return gdb_old_mmap;
1332     case 91: return gdb_sys_munmap;
1333     case 92: return gdb_sys_truncate;
1334     case 93: return gdb_sys_ftruncate;
1335     case 94: return gdb_sys_fchmod;
1336     case 95: return gdb_sys_fchown16;
1337     case 96: return gdb_sys_getpriority;
1338     case 97: return gdb_sys_setpriority;
1339     case 99: return gdb_sys_statfs;
1340     case 100: return gdb_sys_fstatfs;
1341     case 102: return gdb_sys_socketcall;
1342     case 103: return gdb_sys_syslog;
1343     case 104: return gdb_sys_setitimer;
1344     case 105: return gdb_sys_getitimer;
1345     case 106: return gdb_sys_stat;
1346     case 107: return gdb_sys_lstat;
1347     case 108: return gdb_sys_fstat;
1348     case 111: return gdb_sys_vhangup;
1349     case 113: /* sys_syscall */
1350       return gdb_sys_no_syscall;
1351     case 114: return gdb_sys_wait4;
1352     case 115: return gdb_sys_swapoff;
1353     case 116: return gdb_sys_sysinfo;
1354     case 117: return gdb_sys_ipc;
1355     case 118: return gdb_sys_fsync;
1356     case 119: return gdb_sys_sigreturn;
1357     case 120: return gdb_sys_clone;
1358     case 121: return gdb_sys_setdomainname;
1359     case 122: return gdb_sys_uname;
1360     case 124: return gdb_sys_adjtimex;
1361     case 125: return gdb_sys_mprotect;
1362     case 126: return gdb_sys_sigprocmask;
1363     case 128: return gdb_sys_init_module;
1364     case 129: return gdb_sys_delete_module;
1365     case 131: return gdb_sys_quotactl;
1366     case 132: return gdb_sys_getpgid;
1367     case 133: return gdb_sys_fchdir;
1368     case 134: return gdb_sys_bdflush;
1369     case 135: return gdb_sys_sysfs;
1370     case 136: return gdb_sys_personality;
1371     case 138: return gdb_sys_setfsuid16;
1372     case 139: return gdb_sys_setfsgid16;
1373     case 140: return gdb_sys_llseek;
1374     case 141: return gdb_sys_getdents;
1375     case 142: return gdb_sys_select;
1376     case 143: return gdb_sys_flock;
1377     case 144: return gdb_sys_msync;
1378     case 145: return gdb_sys_readv;
1379     case 146: return gdb_sys_writev;
1380     case 147: return gdb_sys_getsid;
1381     case 148: return gdb_sys_fdatasync;
1382     case 149: return gdb_sys_sysctl;
1383     case 150: return gdb_sys_mlock;
1384     case 151: return gdb_sys_munlock;
1385     case 152: return gdb_sys_mlockall;
1386     case 153: return gdb_sys_munlockall;
1387     case 154: return gdb_sys_sched_setparam;
1388     case 155: return gdb_sys_sched_getparam;
1389     case 156: return gdb_sys_sched_setscheduler;
1390     case 157: return gdb_sys_sched_getscheduler;
1391     case 158: return gdb_sys_sched_yield;
1392     case 159: return gdb_sys_sched_get_priority_max;
1393     case 160: return gdb_sys_sched_get_priority_min;
1394     case 161: return gdb_sys_sched_rr_get_interval;
1395     case 162: return gdb_sys_nanosleep;
1396     case 163: return gdb_sys_mremap;
1397     case 164: return gdb_sys_setresuid16;
1398     case 165: return gdb_sys_getresuid16;
1399     case 168: return gdb_sys_poll;
1400     case 169: return gdb_sys_nfsservctl;
1401     case 170: return gdb_sys_setresgid;
1402     case 171: return gdb_sys_getresgid;
1403     case 172: return gdb_sys_prctl;
1404     case 173: return gdb_sys_rt_sigreturn;
1405     case 174: return gdb_sys_rt_sigaction;
1406     case 175: return gdb_sys_rt_sigprocmask;
1407     case 176: return gdb_sys_rt_sigpending;
1408     case 177: return gdb_sys_rt_sigtimedwait;
1409     case 178: return gdb_sys_rt_sigqueueinfo;
1410     case 179: return gdb_sys_rt_sigsuspend;
1411     case 180: return gdb_sys_pread64;
1412     case 181: return gdb_sys_pwrite64;
1413     case 182: return gdb_sys_chown;
1414     case 183: return gdb_sys_getcwd;
1415     case 184: return gdb_sys_capget;
1416     case 185: return gdb_sys_capset;
1417     case 186: return gdb_sys_sigaltstack;
1418     case 187: return gdb_sys_sendfile;
1419     case 190: return gdb_sys_vfork;
1420     case 191: return gdb_sys_getrlimit;
1421     case 192: return gdb_sys_mmap2;
1422     case 193: return gdb_sys_truncate64;
1423     case 194: return gdb_sys_ftruncate64;
1424     case 195: return gdb_sys_stat64;
1425     case 196: return gdb_sys_lstat64;
1426     case 197: return gdb_sys_fstat64;
1427     case 198: return gdb_sys_lchown;
1428     case 199: return gdb_sys_getuid;
1429     case 200: return gdb_sys_getgid;
1430     case 201: return gdb_sys_geteuid;
1431     case 202: return gdb_sys_getegid;
1432     case 203: return gdb_sys_setreuid;
1433     case 204: return gdb_sys_setregid;
1434     case 205: return gdb_sys_getgroups;
1435     case 206: return gdb_sys_setgroups;
1436     case 207: return gdb_sys_fchown;
1437     case 208: return gdb_sys_setresuid;
1438     case 209: return gdb_sys_getresuid;
1439     case 210: return gdb_sys_setresgid;
1440     case 211: return gdb_sys_getresgid;
1441     case 212: return gdb_sys_chown;
1442     case 213: return gdb_sys_setuid;
1443     case 214: return gdb_sys_setgid;
1444     case 215: return gdb_sys_setfsuid;
1445     case 216: return gdb_sys_setfsgid;
1446     case 217: return gdb_sys_getdents64;
1447     case 218: return gdb_sys_pivot_root;
1448     case 219: return gdb_sys_mincore;
1449     case 220: return gdb_sys_madvise;
1450     case 221: return gdb_sys_fcntl64;
1451     case 224: return gdb_sys_gettid;
1452     case 225: return gdb_sys_readahead;
1453     case 226: return gdb_sys_setxattr;
1454     case 227: return gdb_sys_lsetxattr;
1455     case 228: return gdb_sys_fsetxattr;
1456     case 229: return gdb_sys_getxattr;
1457     case 230: return gdb_sys_lgetxattr;
1458     case 231: return gdb_sys_fgetxattr;
1459     case 232: return gdb_sys_listxattr;
1460     case 233: return gdb_sys_llistxattr;
1461     case 234: return gdb_sys_flistxattr;
1462     case 235: return gdb_sys_removexattr;
1463     case 236: return gdb_sys_lremovexattr;
1464     case 237: return gdb_sys_fremovexattr;
1465     case 238: return gdb_sys_tkill;
1466     case 239: return gdb_sys_sendfile64;
1467     case 240: return gdb_sys_futex;
1468     case 241: return gdb_sys_sched_setaffinity;
1469     case 242: return gdb_sys_sched_getaffinity;
1470     case 243: return gdb_sys_io_setup;
1471     case 244: return gdb_sys_io_destroy;
1472     case 245: return gdb_sys_io_getevents;
1473     case 246: return gdb_sys_io_submit;
1474     case 247: return gdb_sys_io_cancel;
1475     case 248: return gdb_sys_exit_group;
1476     case 249: return gdb_sys_lookup_dcookie;
1477     case 250: return gdb_sys_epoll_create;
1478     case 251: return gdb_sys_epoll_ctl;
1479     case 252: return gdb_sys_epoll_wait;
1480     case 253: return gdb_sys_remap_file_pages;
1481     case 256: return gdb_sys_set_tid_address;
1482     case 257: return gdb_sys_timer_create;
1483     case 258: return gdb_sys_timer_settime;
1484     case 259: return gdb_sys_timer_gettime;
1485     case 260: return gdb_sys_timer_getoverrun;
1486     case 261: return gdb_sys_timer_delete;
1487     case 262: return gdb_sys_clock_settime;
1488     case 263: return gdb_sys_clock_gettime;
1489     case 264: return gdb_sys_clock_getres;
1490     case 265: return gdb_sys_clock_nanosleep;
1491     case 266: return gdb_sys_statfs64;
1492     case 267: return gdb_sys_fstatfs64;
1493     case 268: return gdb_sys_tgkill;
1494     case 269: return gdb_sys_utimes;
1495       /*
1496     case 270: return gdb_sys_arm_fadvise64_64;
1497     case 271: return gdb_sys_pciconfig_iobase;
1498     case 272: return gdb_sys_pciconfig_read;
1499     case 273: return gdb_sys_pciconfig_write;
1500       */
1501     case 274: return gdb_sys_mq_open;
1502     case 275: return gdb_sys_mq_unlink;
1503     case 276: return gdb_sys_mq_timedsend;
1504     case 277: return gdb_sys_mq_timedreceive;
1505     case 278: return gdb_sys_mq_notify;
1506     case 279: return gdb_sys_mq_getsetattr;
1507     case 280: return gdb_sys_waitid;
1508     case 281: return gdb_sys_socket;
1509     case 282: return gdb_sys_bind;
1510     case 283: return gdb_sys_connect;
1511     case 284: return gdb_sys_listen;
1512     case 285: return gdb_sys_accept;
1513     case 286: return gdb_sys_getsockname;
1514     case 287: return gdb_sys_getpeername;
1515     case 288: return gdb_sys_socketpair;
1516     case 289: /* send */ return gdb_sys_no_syscall;
1517     case 290: return gdb_sys_sendto;
1518     case 291: return gdb_sys_recv;
1519     case 292: return gdb_sys_recvfrom;
1520     case 293: return gdb_sys_shutdown;
1521     case 294: return gdb_sys_setsockopt;
1522     case 295: return gdb_sys_getsockopt;
1523     case 296: return gdb_sys_sendmsg;
1524     case 297: return gdb_sys_recvmsg;
1525     case 298: return gdb_sys_semop;
1526     case 299: return gdb_sys_semget;
1527     case 300: return gdb_sys_semctl;
1528     case 301: return gdb_sys_msgsnd;
1529     case 302: return gdb_sys_msgrcv;
1530     case 303: return gdb_sys_msgget;
1531     case 304: return gdb_sys_msgctl;
1532     case 305: return gdb_sys_shmat;
1533     case 306: return gdb_sys_shmdt;
1534     case 307: return gdb_sys_shmget;
1535     case 308: return gdb_sys_shmctl;
1536     case 309: return gdb_sys_add_key;
1537     case 310: return gdb_sys_request_key;
1538     case 311: return gdb_sys_keyctl;
1539     case 312: return gdb_sys_semtimedop;
1540     case 313: /* vserver */ return gdb_sys_no_syscall;
1541     case 314: return gdb_sys_ioprio_set;
1542     case 315: return gdb_sys_ioprio_get;
1543     case 316: return gdb_sys_inotify_init;
1544     case 317: return gdb_sys_inotify_add_watch;
1545     case 318: return gdb_sys_inotify_rm_watch;
1546     case 319: return gdb_sys_mbind;
1547     case 320: return gdb_sys_get_mempolicy;
1548     case 321: return gdb_sys_set_mempolicy;
1549     case 322: return gdb_sys_openat;
1550     case 323: return gdb_sys_mkdirat;
1551     case 324: return gdb_sys_mknodat;
1552     case 325: return gdb_sys_fchownat;
1553     case 326: return gdb_sys_futimesat;
1554     case 327: return gdb_sys_fstatat64;
1555     case 328: return gdb_sys_unlinkat;
1556     case 329: return gdb_sys_renameat;
1557     case 330: return gdb_sys_linkat;
1558     case 331: return gdb_sys_symlinkat;
1559     case 332: return gdb_sys_readlinkat;
1560     case 333: return gdb_sys_fchmodat;
1561     case 334: return gdb_sys_faccessat;
1562     case 335: return gdb_sys_pselect6;
1563     case 336: return gdb_sys_ppoll;
1564     case 337: return gdb_sys_unshare;
1565     case 338: return gdb_sys_set_robust_list;
1566     case 339: return gdb_sys_get_robust_list;
1567     case 340: return gdb_sys_splice;
1568     /*case 341: return gdb_sys_arm_sync_file_range;*/
1569     case 342: return gdb_sys_tee;
1570     case 343: return gdb_sys_vmsplice;
1571     case 344: return gdb_sys_move_pages;
1572     case 345: return gdb_sys_getcpu;
1573     case 346: return gdb_sys_epoll_pwait;
1574     case 347: return gdb_sys_kexec_load;
1575       /*
1576     case 348: return gdb_sys_utimensat;
1577     case 349: return gdb_sys_signalfd;
1578     case 350: return gdb_sys_timerfd_create;
1579     case 351: return gdb_sys_eventfd;
1580       */
1581     case 352: return gdb_sys_fallocate;
1582       /*
1583     case 353: return gdb_sys_timerfd_settime;
1584     case 354: return gdb_sys_timerfd_gettime;
1585     case 355: return gdb_sys_signalfd4;
1586       */
1587     case 356: return gdb_sys_eventfd2;
1588     case 357: return gdb_sys_epoll_create1;
1589     case 358: return gdb_sys_dup3;
1590     case 359: return gdb_sys_pipe2;
1591     case 360: return gdb_sys_inotify_init1;
1592       /*
1593     case 361: return gdb_sys_preadv;
1594     case 362: return gdb_sys_pwritev;
1595     case 363: return gdb_sys_rt_tgsigqueueinfo;
1596     case 364: return gdb_sys_perf_event_open;
1597     case 365: return gdb_sys_recvmmsg;
1598     case 366: return gdb_sys_accept4;
1599     case 367: return gdb_sys_fanotify_init;
1600     case 368: return gdb_sys_fanotify_mark;
1601     case 369: return gdb_sys_prlimit64;
1602     case 370: return gdb_sys_name_to_handle_at;
1603     case 371: return gdb_sys_open_by_handle_at;
1604     case 372: return gdb_sys_clock_adjtime;
1605     case 373: return gdb_sys_syncfs;
1606     case 374: return gdb_sys_sendmmsg;
1607     case 375: return gdb_sys_setns;
1608     case 376: return gdb_sys_process_vm_readv;
1609     case 377: return gdb_sys_process_vm_writev;
1610     case 378: return gdb_sys_kcmp;
1611     case 379: return gdb_sys_finit_module;
1612       */
1613     case 983041: /* ARM_breakpoint */ return gdb_sys_no_syscall;
1614     case 983042: /* ARM_cacheflush */ return gdb_sys_no_syscall;
1615     case 983043: /* ARM_usr26 */ return gdb_sys_no_syscall;
1616     case 983044: /* ARM_usr32 */ return gdb_sys_no_syscall;
1617     case 983045: /* ARM_set_tls */ return gdb_sys_no_syscall;
1618     default: return gdb_sys_no_syscall;
1619     }
1620 }
1621
1622 /* Record all registers but PC register for process-record.  */
1623
1624 static int
1625 arm_all_but_pc_registers_record (struct regcache *regcache)
1626 {
1627   int i;
1628
1629   for (i = 0; i < ARM_PC_REGNUM; i++)
1630     {
1631       if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i))
1632         return -1;
1633     }
1634
1635   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1636     return -1;
1637
1638   return 0;
1639 }
1640
1641 /* Handler for arm system call instruction recording.  */
1642
1643 static int
1644 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number)
1645 {
1646   int ret = 0;
1647   enum gdb_syscall syscall_gdb;
1648
1649   syscall_gdb = arm_canonicalize_syscall (svc_number);
1650
1651   if (syscall_gdb == gdb_sys_no_syscall)
1652     {
1653       fprintf_unfiltered (gdb_stderr,
1654                           _("Process record and replay target doesn't "
1655                             "support syscall number %s\n"),
1656                           plongest (svc_number));
1657       return -1;
1658     }
1659
1660   if (syscall_gdb == gdb_sys_sigreturn
1661       || syscall_gdb == gdb_sys_rt_sigreturn)
1662    {
1663      if (arm_all_but_pc_registers_record (regcache))
1664        return -1;
1665      return 0;
1666    }
1667
1668   ret = record_linux_system_call (syscall_gdb, regcache,
1669                                   &arm_linux_record_tdep);
1670   if (ret != 0)
1671     return ret;
1672
1673   /* Record the return value of the system call.  */
1674   if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM))
1675     return -1;
1676   /* Record LR.  */
1677   if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM))
1678     return -1;
1679   /* Record CPSR.  */
1680   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1681     return -1;
1682
1683   return 0;
1684 }
1685
1686 /* Implement the skip_trampoline_code gdbarch method.  */
1687
1688 static CORE_ADDR
1689 arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1690 {
1691   CORE_ADDR target_pc = arm_skip_stub (frame, pc);
1692
1693   if (target_pc != 0)
1694     return target_pc;
1695
1696   return find_solib_trampoline_target (frame, pc);
1697 }
1698
1699 /* Implement the gcc_target_options gdbarch method.  */
1700
1701 static std::string
1702 arm_linux_gcc_target_options (struct gdbarch *gdbarch)
1703 {
1704   /* GCC doesn't know "-m32".  */
1705   return {};
1706 }
1707
1708 static void
1709 arm_linux_init_abi (struct gdbarch_info info,
1710                     struct gdbarch *gdbarch)
1711 {
1712   static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL };
1713   static const char *const stap_register_prefixes[] = { "r", NULL };
1714   static const char *const stap_register_indirection_prefixes[] = { "[",
1715                                                                     NULL };
1716   static const char *const stap_register_indirection_suffixes[] = { "]",
1717                                                                     NULL };
1718   arm_gdbarch_tdep *tdep = (arm_gdbarch_tdep *) gdbarch_tdep (gdbarch);
1719
1720   linux_init_abi (info, gdbarch, 1);
1721
1722   tdep->lowest_pc = 0x8000;
1723   if (info.byte_order_for_code == BFD_ENDIAN_BIG)
1724     {
1725       if (tdep->arm_abi == ARM_ABI_AAPCS)
1726         tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
1727       else
1728         tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
1729       tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
1730       tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
1731     }
1732   else
1733     {
1734       if (tdep->arm_abi == ARM_ABI_AAPCS)
1735         tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
1736       else
1737         tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
1738       tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
1739       tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
1740     }
1741   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
1742   tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
1743   tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);
1744
1745   if (tdep->fp_model == ARM_FLOAT_AUTO)
1746     tdep->fp_model = ARM_FLOAT_FPA;
1747
1748   switch (tdep->fp_model)
1749     {
1750     case ARM_FLOAT_FPA:
1751       tdep->jb_pc = ARM_LINUX_JB_PC_FPA;
1752       break;
1753     case ARM_FLOAT_SOFT_FPA:
1754     case ARM_FLOAT_SOFT_VFP:
1755     case ARM_FLOAT_VFP:
1756       tdep->jb_pc = ARM_LINUX_JB_PC_EABI;
1757       break;
1758     default:
1759       internal_error
1760         (__FILE__, __LINE__,
1761          _("arm_linux_init_abi: Floating point model not supported"));
1762       break;
1763     }
1764   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
1765
1766   set_solib_svr4_fetch_link_map_offsets
1767     (gdbarch, linux_ilp32_fetch_link_map_offsets);
1768
1769   /* Single stepping.  */
1770   set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
1771
1772   /* Shared library handling.  */
1773   set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code);
1774   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1775
1776   /* Enable TLS support.  */
1777   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1778                                              svr4_fetch_objfile_link_map);
1779
1780   tramp_frame_prepend_unwinder (gdbarch,
1781                                 &arm_linux_sigreturn_tramp_frame);
1782   tramp_frame_prepend_unwinder (gdbarch,
1783                                 &arm_linux_rt_sigreturn_tramp_frame);
1784   tramp_frame_prepend_unwinder (gdbarch,
1785                                 &arm_eabi_linux_sigreturn_tramp_frame);
1786   tramp_frame_prepend_unwinder (gdbarch,
1787                                 &arm_eabi_linux_rt_sigreturn_tramp_frame);
1788   tramp_frame_prepend_unwinder (gdbarch,
1789                                 &thumb2_eabi_linux_sigreturn_tramp_frame);
1790   tramp_frame_prepend_unwinder (gdbarch,
1791                                 &thumb2_eabi_linux_rt_sigreturn_tramp_frame);
1792   tramp_frame_prepend_unwinder (gdbarch,
1793                                 &arm_linux_restart_syscall_tramp_frame);
1794   tramp_frame_prepend_unwinder (gdbarch,
1795                                 &arm_kernel_linux_restart_syscall_tramp_frame);
1796
1797   /* Core file support.  */
1798   set_gdbarch_iterate_over_regset_sections
1799     (gdbarch, arm_linux_iterate_over_regset_sections);
1800   set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description);
1801
1802   /* Displaced stepping.  */
1803   set_gdbarch_displaced_step_copy_insn (gdbarch,
1804                                         arm_linux_displaced_step_copy_insn);
1805   set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
1806
1807   /* Reversible debugging, process record.  */
1808   set_gdbarch_process_record (gdbarch, arm_process_record);
1809
1810   /* SystemTap functions.  */
1811   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1812   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1813   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
1814                                           stap_register_indirection_prefixes);
1815   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
1816                                           stap_register_indirection_suffixes);
1817   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
1818   set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand);
1819   set_gdbarch_stap_parse_special_token (gdbarch,
1820                                         arm_stap_parse_special_token);
1821
1822   /* `catch syscall' */
1823   set_xml_syscall_file_name (gdbarch, "syscalls/arm-linux.xml");
1824   set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number);
1825
1826   /* Syscall record.  */
1827   tdep->arm_syscall_record = arm_linux_syscall_record;
1828
1829   /* Initialize the arm_linux_record_tdep.  */
1830   /* These values are the size of the type that will be used in a system
1831      call.  They are obtained from Linux Kernel source.  */
1832   arm_linux_record_tdep.size_pointer
1833     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1834   arm_linux_record_tdep.size__old_kernel_stat = 32;
1835   arm_linux_record_tdep.size_tms = 16;
1836   arm_linux_record_tdep.size_loff_t = 8;
1837   arm_linux_record_tdep.size_flock = 16;
1838   arm_linux_record_tdep.size_oldold_utsname = 45;
1839   arm_linux_record_tdep.size_ustat = 20;
1840   arm_linux_record_tdep.size_old_sigaction = 16;
1841   arm_linux_record_tdep.size_old_sigset_t = 4;
1842   arm_linux_record_tdep.size_rlimit = 8;
1843   arm_linux_record_tdep.size_rusage = 72;
1844   arm_linux_record_tdep.size_timeval = 8;
1845   arm_linux_record_tdep.size_timezone = 8;
1846   arm_linux_record_tdep.size_old_gid_t = 2;
1847   arm_linux_record_tdep.size_old_uid_t = 2;
1848   arm_linux_record_tdep.size_fd_set = 128;
1849   arm_linux_record_tdep.size_old_dirent = 268;
1850   arm_linux_record_tdep.size_statfs = 64;
1851   arm_linux_record_tdep.size_statfs64 = 84;
1852   arm_linux_record_tdep.size_sockaddr = 16;
1853   arm_linux_record_tdep.size_int
1854     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1855   arm_linux_record_tdep.size_long
1856     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1857   arm_linux_record_tdep.size_ulong
1858     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1859   arm_linux_record_tdep.size_msghdr = 28;
1860   arm_linux_record_tdep.size_itimerval = 16;
1861   arm_linux_record_tdep.size_stat = 88;
1862   arm_linux_record_tdep.size_old_utsname = 325;
1863   arm_linux_record_tdep.size_sysinfo = 64;
1864   arm_linux_record_tdep.size_msqid_ds = 88;
1865   arm_linux_record_tdep.size_shmid_ds = 84;
1866   arm_linux_record_tdep.size_new_utsname = 390;
1867   arm_linux_record_tdep.size_timex = 128;
1868   arm_linux_record_tdep.size_mem_dqinfo = 24;
1869   arm_linux_record_tdep.size_if_dqblk = 68;
1870   arm_linux_record_tdep.size_fs_quota_stat = 68;
1871   arm_linux_record_tdep.size_timespec = 8;
1872   arm_linux_record_tdep.size_pollfd = 8;
1873   arm_linux_record_tdep.size_NFS_FHSIZE = 32;
1874   arm_linux_record_tdep.size_knfsd_fh = 132;
1875   arm_linux_record_tdep.size_TASK_COMM_LEN = 16;
1876   arm_linux_record_tdep.size_sigaction = 20;
1877   arm_linux_record_tdep.size_sigset_t = 8;
1878   arm_linux_record_tdep.size_siginfo_t = 128;
1879   arm_linux_record_tdep.size_cap_user_data_t = 12;
1880   arm_linux_record_tdep.size_stack_t = 12;
1881   arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long;
1882   arm_linux_record_tdep.size_stat64 = 96;
1883   arm_linux_record_tdep.size_gid_t = 4;
1884   arm_linux_record_tdep.size_uid_t = 4;
1885   arm_linux_record_tdep.size_PAGE_SIZE = 4096;
1886   arm_linux_record_tdep.size_flock64 = 24;
1887   arm_linux_record_tdep.size_user_desc = 16;
1888   arm_linux_record_tdep.size_io_event = 32;
1889   arm_linux_record_tdep.size_iocb = 64;
1890   arm_linux_record_tdep.size_epoll_event = 12;
1891   arm_linux_record_tdep.size_itimerspec
1892     = arm_linux_record_tdep.size_timespec * 2;
1893   arm_linux_record_tdep.size_mq_attr = 32;
1894   arm_linux_record_tdep.size_termios = 36;
1895   arm_linux_record_tdep.size_termios2 = 44;
1896   arm_linux_record_tdep.size_pid_t = 4;
1897   arm_linux_record_tdep.size_winsize = 8;
1898   arm_linux_record_tdep.size_serial_struct = 60;
1899   arm_linux_record_tdep.size_serial_icounter_struct = 80;
1900   arm_linux_record_tdep.size_hayes_esp_config = 12;
1901   arm_linux_record_tdep.size_size_t = 4;
1902   arm_linux_record_tdep.size_iovec = 8;
1903   arm_linux_record_tdep.size_time_t = 4;
1904
1905   /* These values are the second argument of system call "sys_ioctl".
1906      They are obtained from Linux Kernel source.  */
1907   arm_linux_record_tdep.ioctl_TCGETS = 0x5401;
1908   arm_linux_record_tdep.ioctl_TCSETS = 0x5402;
1909   arm_linux_record_tdep.ioctl_TCSETSW = 0x5403;
1910   arm_linux_record_tdep.ioctl_TCSETSF = 0x5404;
1911   arm_linux_record_tdep.ioctl_TCGETA = 0x5405;
1912   arm_linux_record_tdep.ioctl_TCSETA = 0x5406;
1913   arm_linux_record_tdep.ioctl_TCSETAW = 0x5407;
1914   arm_linux_record_tdep.ioctl_TCSETAF = 0x5408;
1915   arm_linux_record_tdep.ioctl_TCSBRK = 0x5409;
1916   arm_linux_record_tdep.ioctl_TCXONC = 0x540a;
1917   arm_linux_record_tdep.ioctl_TCFLSH = 0x540b;
1918   arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
1919   arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
1920   arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
1921   arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
1922   arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
1923   arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
1924   arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
1925   arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
1926   arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
1927   arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
1928   arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
1929   arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
1930   arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
1931   arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
1932   arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
1933   arm_linux_record_tdep.ioctl_FIONREAD = 0x541b;
1934   arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD;
1935   arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
1936   arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
1937   arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
1938   arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
1939   arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
1940   arm_linux_record_tdep.ioctl_FIONBIO = 0x5421;
1941   arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
1942   arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
1943   arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
1944   arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
1945   arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
1946   arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
1947   arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
1948   arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
1949   arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1950   arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1951   arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
1952   arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1953   arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1954   arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1955   arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1956   arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1957   arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1958   arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1959   arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1960   arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1961   arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1962   arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1963   arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1964   arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1965   arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
1966   arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
1967   arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
1968   arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
1969   arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
1970   arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
1971   arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1972
1973   /* These values are the second argument of system call "sys_fcntl"
1974      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1975   arm_linux_record_tdep.fcntl_F_GETLK = 5;
1976   arm_linux_record_tdep.fcntl_F_GETLK64 = 12;
1977   arm_linux_record_tdep.fcntl_F_SETLK64 = 13;
1978   arm_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1979
1980   arm_linux_record_tdep.arg1 = ARM_A1_REGNUM;
1981   arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 1;
1982   arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 2;
1983   arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3;
1984   arm_linux_record_tdep.arg5 = ARM_A1_REGNUM + 4;
1985   arm_linux_record_tdep.arg6 = ARM_A1_REGNUM + 5;
1986   arm_linux_record_tdep.arg7 = ARM_A1_REGNUM + 6;
1987
1988   set_gdbarch_gcc_target_options (gdbarch, arm_linux_gcc_target_options);
1989 }
1990
1991 void _initialize_arm_linux_tdep ();
1992 void
1993 _initialize_arm_linux_tdep ()
1994 {
1995   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
1996                           arm_linux_init_abi);
1997 }
This page took 0.135627 seconds and 4 git commands to generate.