gdb/arm-linux-tdep.c

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