gdb/arm-linux-tdep.c

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