gdb/arm-linux-tdep.c

   1 /* GNU/Linux on ARM target support.
   2
   3    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "target.h"
  22 #include "value.h"
  23 #include "gdbtypes.h"
  24 #include "floatformat.h"
  25 #include "gdbcore.h"
  26 #include "frame.h"
  27 #include "regcache.h"
  28 #include "doublest.h"
  29 #include "solib-svr4.h"
  30 #include "osabi.h"
  31 #include "regset.h"
  32 #include "trad-frame.h"
  33 #include "tramp-frame.h"
  34 #include "breakpoint.h"
  35 #include "auxv.h"
  36 #include "xml-syscall.h"
  37
  38 #include "arm-tdep.h"
  39 #include "arm-linux-tdep.h"
  40 #include "linux-tdep.h"
  41 #include "glibc-tdep.h"
  42 #include "arch-utils.h"
  43 #include "inferior.h"
  44 #include "infrun.h"
  45 #include "gdbthread.h"
  46 #include "symfile.h"
  47
  48 #include "record-full.h"
  49 #include "linux-record.h"
  50
  51 #include "cli/cli-utils.h"
  52 #include "stap-probe.h"
  53 #include "parser-defs.h"
  54 #include "user-regs.h"
  55 #include <ctype.h>
  56 #include "elf/common.h"
  57 extern int arm_apcs_32;
  58
  59 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
  60    is to execute a particular software interrupt, rather than use a
  61    particular undefined instruction to provoke a trap.  Upon exection
  62    of the software interrupt the kernel stops the inferior with a
  63    SIGTRAP, and wakes the debugger.  */
  64
  65 static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
  66
  67 static const gdb_byte arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
  68
  69 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
  70    the operand of the swi if old-ABI compatibility is disabled.  Therefore,
  71    use an undefined instruction instead.  This is supported as of kernel
  72    version 2.5.70 (May 2003), so should be a safe assumption for EABI
  73    binaries.  */
  74
  75 static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
  76
  77 static const gdb_byte eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
  78
  79 /* All the kernels which support Thumb support using a specific undefined
  80    instruction for the Thumb breakpoint.  */
  81
  82 static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
  83
  84 static const gdb_byte arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
  85
  86 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
  87    we must use a length-appropriate breakpoint for 32-bit Thumb
  88    instructions.  See also thumb_get_next_pc.  */
  89
  90 static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };
  91
  92 static const gdb_byte arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 };
  93
  94 /* Description of the longjmp buffer.  The buffer is treated as an array of
  95    elements of size ARM_LINUX_JB_ELEMENT_SIZE.
  96
  97    The location of saved registers in this buffer (in particular the PC
  98    to use after longjmp is called) varies depending on the ABI (in
  99    particular the FP model) and also (possibly) the C Library.
 100
 101    For glibc, eglibc, and uclibc the following holds:  If the FP model is
 102    SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
 103    buffer.  This is also true for the SoftFPA model.  However, for the FPA
 104    model the PC is at offset 21 in the buffer.  */
 105 #define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_SIZE
 106 #define ARM_LINUX_JB_PC_FPA             21
 107 #define ARM_LINUX_JB_PC_EABI            9
 108
 109 /*
 110    Dynamic Linking on ARM GNU/Linux
 111    --------------------------------
 112
 113    Note: PLT = procedure linkage table
 114    GOT = global offset table
 115
 116    As much as possible, ELF dynamic linking defers the resolution of
 117    jump/call addresses until the last minute.  The technique used is
 118    inspired by the i386 ELF design, and is based on the following
 119    constraints.
 120
 121    1) The calling technique should not force a change in the assembly
 122    code produced for apps; it MAY cause changes in the way assembly
 123    code is produced for position independent code (i.e. shared
 124    libraries).
 125
 126    2) The technique must be such that all executable areas must not be
 127    modified; and any modified areas must not be executed.
 128
 129    To do this, there are three steps involved in a typical jump:
 130
 131    1) in the code
 132    2) through the PLT
 133    3) using a pointer from the GOT
 134
 135    When the executable or library is first loaded, each GOT entry is
 136    initialized to point to the code which implements dynamic name
 137    resolution and code finding.  This is normally a function in the
 138    program interpreter (on ARM GNU/Linux this is usually
 139    ld-linux.so.2, but it does not have to be).  On the first
 140    invocation, the function is located and the GOT entry is replaced
 141    with the real function address.  Subsequent calls go through steps
 142    1, 2 and 3 and end up calling the real code.
 143
 144    1) In the code:
 145
 146    b    function_call
 147    bl   function_call
 148
 149    This is typical ARM code using the 26 bit relative branch or branch
 150    and link instructions.  The target of the instruction
 151    (function_call is usually the address of the function to be called.
 152    In position independent code, the target of the instruction is
 153    actually an entry in the PLT when calling functions in a shared
 154    library.  Note that this call is identical to a normal function
 155    call, only the target differs.
 156
 157    2) In the PLT:
 158
 159    The PLT is a synthetic area, created by the linker.  It exists in
 160    both executables and libraries.  It is an array of stubs, one per
 161    imported function call.  It looks like this:
 162
 163    PLT[0]:
 164    str     lr, [sp, #-4]!       @push the return address (lr)
 165    ldr     lr, [pc, #16]   @load from 6 words ahead
 166    add     lr, pc, lr      @form an address for GOT[0]
 167    ldr     pc, [lr, #8]!   @jump to the contents of that addr
 168
 169    The return address (lr) is pushed on the stack and used for
 170    calculations.  The load on the second line loads the lr with
 171    &GOT[3] - . - 20.  The addition on the third leaves:
 172
 173    lr = (&GOT[3] - . - 20) + (. + 8)
 174    lr = (&GOT[3] - 12)
 175    lr = &GOT[0]
 176
 177    On the fourth line, the pc and lr are both updated, so that:
 178
 179    pc = GOT[2]
 180    lr = &GOT[0] + 8
 181    = &GOT[2]
 182
 183    NOTE: PLT[0] borrows an offset .word from PLT[1].  This is a little
 184    "tight", but allows us to keep all the PLT entries the same size.
 185
 186    PLT[n+1]:
 187    ldr     ip, [pc, #4]    @load offset from gotoff
 188    add     ip, pc, ip      @add the offset to the pc
 189    ldr     pc, [ip]        @jump to that address
 190    gotoff: .word   GOT[n+3] - .
 191
 192    The load on the first line, gets an offset from the fourth word of
 193    the PLT entry.  The add on the second line makes ip = &GOT[n+3],
 194    which contains either a pointer to PLT[0] (the fixup trampoline) or
 195    a pointer to the actual code.
 196
 197    3) In the GOT:
 198
 199    The GOT contains helper pointers for both code (PLT) fixups and
 200    data fixups.  The first 3 entries of the GOT are special.  The next
 201    M entries (where M is the number of entries in the PLT) belong to
 202    the PLT fixups.  The next D (all remaining) entries belong to
 203    various data fixups.  The actual size of the GOT is 3 + M + D.
 204
 205    The GOT is also a synthetic area, created by the linker.  It exists
 206    in both executables and libraries.  When the GOT is first
 207    initialized , all the GOT entries relating to PLT fixups are
 208    pointing to code back at PLT[0].
 209
 210    The special entries in the GOT are:
 211
 212    GOT[0] = linked list pointer used by the dynamic loader
 213    GOT[1] = pointer to the reloc table for this module
 214    GOT[2] = pointer to the fixup/resolver code
 215
 216    The first invocation of function call comes through and uses the
 217    fixup/resolver code.  On the entry to the fixup/resolver code:
 218
 219    ip = &GOT[n+3]
 220    lr = &GOT[2]
 221    stack[0] = return address (lr) of the function call
 222    [r0, r1, r2, r3] are still the arguments to the function call
 223
 224    This is enough information for the fixup/resolver code to work
 225    with.  Before the fixup/resolver code returns, it actually calls
 226    the requested function and repairs &GOT[n+3].  */
 227
 228 /* The constants below were determined by examining the following files
 229    in the linux kernel sources:
 230
 231       arch/arm/kernel/signal.c
 232           - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
 233       include/asm-arm/unistd.h
 234           - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
 235
 236 #define ARM_LINUX_SIGRETURN_INSTR       0xef900077
 237 #define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
 238
 239 /* For ARM EABI, the syscall number is not in the SWI instruction
 240    (instead it is loaded into r7).  We recognize the pattern that
 241    glibc uses...  alternatively, we could arrange to do this by
 242    function name, but they are not always exported.  */
 243 #define ARM_SET_R7_SIGRETURN            0xe3a07077
 244 #define ARM_SET_R7_RT_SIGRETURN         0xe3a070ad
 245 #define ARM_EABI_SYSCALL                0xef000000
 246
 247 /* Equivalent patterns for Thumb2.  */
 248 #define THUMB2_SET_R7_SIGRETURN1        0xf04f
 249 #define THUMB2_SET_R7_SIGRETURN2        0x0777
 250 #define THUMB2_SET_R7_RT_SIGRETURN1     0xf04f
 251 #define THUMB2_SET_R7_RT_SIGRETURN2     0x07ad
 252 #define THUMB2_EABI_SYSCALL             0xdf00
 253
 254 /* OABI syscall restart trampoline, used for EABI executables too
 255    whenever OABI support has been enabled in the kernel.  */
 256 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
 257 #define ARM_LDR_PC_SP_12                0xe49df00c
 258 #define ARM_LDR_PC_SP_4                 0xe49df004
 259
 260 static void
 261 arm_linux_sigtramp_cache (struct frame_info *this_frame,
 262                           struct trad_frame_cache *this_cache,
 263                           CORE_ADDR func, int regs_offset)
 264 {
 265   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 266   CORE_ADDR base = sp + regs_offset;
 267   int i;
 268
 269   for (i = 0; i < 16; i++)
 270     trad_frame_set_reg_addr (this_cache, i, base + i * 4);
 271
 272   trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
 273
 274   /* The VFP or iWMMXt registers may be saved on the stack, but there's
 275      no reliable way to restore them (yet).  */
 276
 277   /* Save a frame ID.  */
 278   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 279 }
 280
 281 /* There are a couple of different possible stack layouts that
 282    we need to support.
 283
 284    Before version 2.6.18, the kernel used completely independent
 285    layouts for non-RT and RT signals.  For non-RT signals the stack
 286    began directly with a struct sigcontext.  For RT signals the stack
 287    began with two redundant pointers (to the siginfo and ucontext),
 288    and then the siginfo and ucontext.
 289
 290    As of version 2.6.18, the non-RT signal frame layout starts with
 291    a ucontext and the RT signal frame starts with a siginfo and then
 292    a ucontext.  Also, the ucontext now has a designated save area
 293    for coprocessor registers.
 294
 295    For RT signals, it's easy to tell the difference: we look for
 296    pinfo, the pointer to the siginfo.  If it has the expected
 297    value, we have an old layout.  If it doesn't, we have the new
 298    layout.
 299
 300    For non-RT signals, it's a bit harder.  We need something in one
 301    layout or the other with a recognizable offset and value.  We can't
 302    use the return trampoline, because ARM usually uses SA_RESTORER,
 303    in which case the stack return trampoline is not filled in.
 304    We can't use the saved stack pointer, because sigaltstack might
 305    be in use.  So for now we guess the new layout...  */
 306
 307 /* There are three words (trap_no, error_code, oldmask) in
 308    struct sigcontext before r0.  */
 309 #define ARM_SIGCONTEXT_R0 0xc
 310
 311 /* There are five words (uc_flags, uc_link, and three for uc_stack)
 312    in the ucontext_t before the sigcontext.  */
 313 #define ARM_UCONTEXT_SIGCONTEXT 0x14
 314
 315 /* There are three elements in an rt_sigframe before the ucontext:
 316    pinfo, puc, and info.  The first two are pointers and the third
 317    is a struct siginfo, with size 128 bytes.  We could follow puc
 318    to the ucontext, but it's simpler to skip the whole thing.  */
 319 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
 320 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
 321
 322 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
 323
 324 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
 325
 326 static void
 327 arm_linux_sigreturn_init (const struct tramp_frame *self,
 328                           struct frame_info *this_frame,
 329                           struct trad_frame_cache *this_cache,
 330                           CORE_ADDR func)
 331 {
 332   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 333   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 334   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 335   ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
 336
 337   if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
 338     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 339                               ARM_UCONTEXT_SIGCONTEXT
 340                               + ARM_SIGCONTEXT_R0);
 341   else
 342     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 343                               ARM_SIGCONTEXT_R0);
 344 }
 345
 346 static void
 347 arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
 348                           struct frame_info *this_frame,
 349                           struct trad_frame_cache *this_cache,
 350                           CORE_ADDR func)
 351 {
 352   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 353   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 354   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 355   ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
 356
 357   if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
 358     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 359                               ARM_OLD_RT_SIGFRAME_UCONTEXT
 360                               + ARM_UCONTEXT_SIGCONTEXT
 361                               + ARM_SIGCONTEXT_R0);
 362   else
 363     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 364                               ARM_NEW_RT_SIGFRAME_UCONTEXT
 365                               + ARM_UCONTEXT_SIGCONTEXT
 366                               + ARM_SIGCONTEXT_R0);
 367 }
 368
 369 static void
 370 arm_linux_restart_syscall_init (const struct tramp_frame *self,
 371                                 struct frame_info *this_frame,
 372                                 struct trad_frame_cache *this_cache,
 373                                 CORE_ADDR func)
 374 {
 375   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 376   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 377   CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4);
 378   CORE_ADDR cpsr = get_frame_register_unsigned (this_frame, ARM_PS_REGNUM);
 379   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
 380   int sp_offset;
 381
 382   /* There are two variants of this trampoline; with older kernels, the
 383      stub is placed on the stack, while newer kernels use the stub from
 384      the vector page.  They are identical except that the older version
 385      increments SP by 12 (to skip stored PC and the stub itself), while
 386      the newer version increments SP only by 4 (just the stored PC).  */
 387   if (self->insn[1].bytes == ARM_LDR_PC_SP_4)
 388     sp_offset = 4;
 389   else
 390     sp_offset = 12;
 391
 392   /* Update Thumb bit in CPSR.  */
 393   if (pc & 1)
 394     cpsr |= t_bit;
 395   else
 396     cpsr &= ~t_bit;
 397
 398   /* Remove Thumb bit from PC.  */
 399   pc = gdbarch_addr_bits_remove (gdbarch, pc);
 400
 401   /* Save previous register values.  */
 402   trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset);
 403   trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc);
 404   trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr);
 405
 406   /* Save a frame ID.  */
 407   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 408 }
 409
 410 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
 411   SIGTRAMP_FRAME,
 412   4,
 413   {
 414     { ARM_LINUX_SIGRETURN_INSTR, -1 },
 415     { TRAMP_SENTINEL_INSN }
 416   },
 417   arm_linux_sigreturn_init
 418 };
 419
 420 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
 421   SIGTRAMP_FRAME,
 422   4,
 423   {
 424     { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
 425     { TRAMP_SENTINEL_INSN }
 426   },
 427   arm_linux_rt_sigreturn_init
 428 };
 429
 430 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
 431   SIGTRAMP_FRAME,
 432   4,
 433   {
 434     { ARM_SET_R7_SIGRETURN, -1 },
 435     { ARM_EABI_SYSCALL, -1 },
 436     { TRAMP_SENTINEL_INSN }
 437   },
 438   arm_linux_sigreturn_init
 439 };
 440
 441 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
 442   SIGTRAMP_FRAME,
 443   4,
 444   {
 445     { ARM_SET_R7_RT_SIGRETURN, -1 },
 446     { ARM_EABI_SYSCALL, -1 },
 447     { TRAMP_SENTINEL_INSN }
 448   },
 449   arm_linux_rt_sigreturn_init
 450 };
 451
 452 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = {
 453   SIGTRAMP_FRAME,
 454   2,
 455   {
 456     { THUMB2_SET_R7_SIGRETURN1, -1 },
 457     { THUMB2_SET_R7_SIGRETURN2, -1 },
 458     { THUMB2_EABI_SYSCALL, -1 },
 459     { TRAMP_SENTINEL_INSN }
 460   },
 461   arm_linux_sigreturn_init
 462 };
 463
 464 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = {
 465   SIGTRAMP_FRAME,
 466   2,
 467   {
 468     { THUMB2_SET_R7_RT_SIGRETURN1, -1 },
 469     { THUMB2_SET_R7_RT_SIGRETURN2, -1 },
 470     { THUMB2_EABI_SYSCALL, -1 },
 471     { TRAMP_SENTINEL_INSN }
 472   },
 473   arm_linux_rt_sigreturn_init
 474 };
 475
 476 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
 477   NORMAL_FRAME,
 478   4,
 479   {
 480     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
 481     { ARM_LDR_PC_SP_12, -1 },
 482     { TRAMP_SENTINEL_INSN }
 483   },
 484   arm_linux_restart_syscall_init
 485 };
 486
 487 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
 488   NORMAL_FRAME,
 489   4,
 490   {
 491     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
 492     { ARM_LDR_PC_SP_4, -1 },
 493     { TRAMP_SENTINEL_INSN }
 494   },
 495   arm_linux_restart_syscall_init
 496 };
 497
 498 /* Core file and register set support.  */
 499
 500 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
 501
 502 void
 503 arm_linux_supply_gregset (const struct regset *regset,
 504                           struct regcache *regcache,
 505                           int regnum, const void *gregs_buf, size_t len)
 506 {
 507   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 508   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 509   const gdb_byte *gregs = gregs_buf;
 510   int regno;
 511   CORE_ADDR reg_pc;
 512   gdb_byte pc_buf[INT_REGISTER_SIZE];
 513
 514   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 515     if (regnum == -1 || regnum == regno)
 516       regcache_raw_supply (regcache, regno,
 517                            gregs + INT_REGISTER_SIZE * regno);
 518
 519   if (regnum == ARM_PS_REGNUM || regnum == -1)
 520     {
 521       if (arm_apcs_32)
 522         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 523                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 524       else
 525         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 526                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 527     }
 528
 529   if (regnum == ARM_PC_REGNUM || regnum == -1)
 530     {
 531       reg_pc = extract_unsigned_integer (gregs
 532                                          + INT_REGISTER_SIZE * ARM_PC_REGNUM,
 533                                          INT_REGISTER_SIZE, byte_order);
 534       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
 535       store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
 536       regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
 537     }
 538 }
 539
 540 void
 541 arm_linux_collect_gregset (const struct regset *regset,
 542                            const struct regcache *regcache,
 543                            int regnum, void *gregs_buf, size_t len)
 544 {
 545   gdb_byte *gregs = gregs_buf;
 546   int regno;
 547
 548   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 549     if (regnum == -1 || regnum == regno)
 550       regcache_raw_collect (regcache, regno,
 551                             gregs + INT_REGISTER_SIZE * regno);
 552
 553   if (regnum == ARM_PS_REGNUM || regnum == -1)
 554     {
 555       if (arm_apcs_32)
 556         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 557                               gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 558       else
 559         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 560                               gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 561     }
 562
 563   if (regnum == ARM_PC_REGNUM || regnum == -1)
 564     regcache_raw_collect (regcache, ARM_PC_REGNUM,
 565                           gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 566 }
 567
 568 /* Support for register format used by the NWFPE FPA emulator.  */
 569
 570 #define typeNone                0x00
 571 #define typeSingle              0x01
 572 #define typeDouble              0x02
 573 #define typeExtended            0x03
 574
 575 void
 576 supply_nwfpe_register (struct regcache *regcache, int regno,
 577                        const gdb_byte *regs)
 578 {
 579   const gdb_byte *reg_data;
 580   gdb_byte reg_tag;
 581   gdb_byte buf[FP_REGISTER_SIZE];
 582
 583   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 584   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 585   memset (buf, 0, FP_REGISTER_SIZE);
 586
 587   switch (reg_tag)
 588     {
 589     case typeSingle:
 590       memcpy (buf, reg_data, 4);
 591       break;
 592     case typeDouble:
 593       memcpy (buf, reg_data + 4, 4);
 594       memcpy (buf + 4, reg_data, 4);
 595       break;
 596     case typeExtended:
 597       /* We want sign and exponent, then least significant bits,
 598          then most significant.  NWFPE does sign, most, least.  */
 599       memcpy (buf, reg_data, 4);
 600       memcpy (buf + 4, reg_data + 8, 4);
 601       memcpy (buf + 8, reg_data + 4, 4);
 602       break;
 603     default:
 604       break;
 605     }
 606
 607   regcache_raw_supply (regcache, regno, buf);
 608 }
 609
 610 void
 611 collect_nwfpe_register (const struct regcache *regcache, int regno,
 612                         gdb_byte *regs)
 613 {
 614   gdb_byte *reg_data;
 615   gdb_byte reg_tag;
 616   gdb_byte buf[FP_REGISTER_SIZE];
 617
 618   regcache_raw_collect (regcache, regno, buf);
 619
 620   /* NOTE drow/2006-06-07: This code uses the tag already in the
 621      register buffer.  I've preserved that when moving the code
 622      from the native file to the target file.  But this doesn't
 623      always make sense.  */
 624
 625   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 626   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 627
 628   switch (reg_tag)
 629     {
 630     case typeSingle:
 631       memcpy (reg_data, buf, 4);
 632       break;
 633     case typeDouble:
 634       memcpy (reg_data, buf + 4, 4);
 635       memcpy (reg_data + 4, buf, 4);
 636       break;
 637     case typeExtended:
 638       memcpy (reg_data, buf, 4);
 639       memcpy (reg_data + 4, buf + 8, 4);
 640       memcpy (reg_data + 8, buf + 4, 4);
 641       break;
 642     default:
 643       break;
 644     }
 645 }
 646
 647 void
 648 arm_linux_supply_nwfpe (const struct regset *regset,
 649                         struct regcache *regcache,
 650                         int regnum, const void *regs_buf, size_t len)
 651 {
 652   const gdb_byte *regs = regs_buf;
 653   int regno;
 654
 655   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 656     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 657                          regs + NWFPE_FPSR_OFFSET);
 658
 659   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 660     if (regnum == -1 || regnum == regno)
 661       supply_nwfpe_register (regcache, regno, regs);
 662 }
 663
 664 void
 665 arm_linux_collect_nwfpe (const struct regset *regset,
 666                          const struct regcache *regcache,
 667                          int regnum, void *regs_buf, size_t len)
 668 {
 669   gdb_byte *regs = regs_buf;
 670   int regno;
 671
 672   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 673     if (regnum == -1 || regnum == regno)
 674       collect_nwfpe_register (regcache, regno, regs);
 675
 676   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 677     regcache_raw_collect (regcache, ARM_FPS_REGNUM,
 678                           regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
 679 }
 680
 681 /* Support VFP register format.  */
 682
 683 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
 684
 685 static void
 686 arm_linux_supply_vfp (const struct regset *regset,
 687                       struct regcache *regcache,
 688                       int regnum, const void *regs_buf, size_t len)
 689 {
 690   const gdb_byte *regs = regs_buf;
 691   int regno;
 692
 693   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
 694     regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
 695
 696   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
 697     if (regnum == -1 || regnum == regno)
 698       regcache_raw_supply (regcache, regno,
 699                            regs + (regno - ARM_D0_REGNUM) * 8);
 700 }
 701
 702 static void
 703 arm_linux_collect_vfp (const struct regset *regset,
 704                          const struct regcache *regcache,
 705                          int regnum, void *regs_buf, size_t len)
 706 {
 707   gdb_byte *regs = regs_buf;
 708   int regno;
 709
 710   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
 711     regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
 712
 713   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
 714     if (regnum == -1 || regnum == regno)
 715       regcache_raw_collect (regcache, regno,
 716                             regs + (regno - ARM_D0_REGNUM) * 8);
 717 }
 718
 719 static const struct regset arm_linux_gregset =
 720   {
 721     NULL, arm_linux_supply_gregset, arm_linux_collect_gregset
 722   };
 723
 724 static const struct regset arm_linux_fpregset =
 725   {
 726     NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe
 727   };
 728
 729 static const struct regset arm_linux_vfpregset =
 730   {
 731     NULL, arm_linux_supply_vfp, arm_linux_collect_vfp
 732   };
 733
 734 /* Return the appropriate register set for the core section identified
 735    by SECT_NAME and SECT_SIZE.  */
 736
 737 static const struct regset *
 738 arm_linux_regset_from_core_section (struct gdbarch *gdbarch,
 739                                     const char *sect_name, size_t sect_size)
 740 {
 741   if (strcmp (sect_name, ".reg") == 0
 742       && sect_size == ARM_LINUX_SIZEOF_GREGSET)
 743     return &arm_linux_gregset;
 744
 745   if (strcmp (sect_name, ".reg2") == 0
 746       && sect_size == ARM_LINUX_SIZEOF_NWFPE)
 747     return &arm_linux_fpregset;
 748
 749   if (strcmp (sect_name, ".reg-arm-vfp") == 0
 750       && sect_size == ARM_LINUX_SIZEOF_VFP)
 751     return &arm_linux_vfpregset;
 752
 753   return NULL;
 754 }
 755
 756 /* Core file register set sections.  */
 757
 758 static struct core_regset_section arm_linux_fpa_regset_sections[] =
 759 {
 760   { ".reg", ARM_LINUX_SIZEOF_GREGSET, "general-purpose" },
 761   { ".reg2", ARM_LINUX_SIZEOF_NWFPE, "FPA floating-point" },
 762   { NULL, 0}
 763 };
 764
 765 static struct core_regset_section arm_linux_vfp_regset_sections[] =
 766 {
 767   { ".reg", ARM_LINUX_SIZEOF_GREGSET, "general-purpose" },
 768   { ".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP, "VFP floating-point" },
 769   { NULL, 0}
 770 };
 771
 772 /* Determine target description from core file.  */
 773
 774 static const struct target_desc *
 775 arm_linux_core_read_description (struct gdbarch *gdbarch,
 776                                  struct target_ops *target,
 777                                  bfd *abfd)
 778 {
 779   CORE_ADDR arm_hwcap = 0;
 780
 781   if (target_auxv_search (target, AT_HWCAP, &arm_hwcap) != 1)
 782     return NULL;
 783
 784   if (arm_hwcap & HWCAP_VFP)
 785     {
 786       /* NEON implies VFPv3-D32 or no-VFP unit.  Say that we only support
 787          Neon with VFPv3-D32.  */
 788       if (arm_hwcap & HWCAP_NEON)
 789         return tdesc_arm_with_neon;
 790       else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
 791         return tdesc_arm_with_vfpv3;
 792       else
 793         return tdesc_arm_with_vfpv2;
 794     }
 795
 796   return NULL;
 797 }
 798
 799
 800 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
 801    return 1.  In addition, set IS_THUMB depending on whether we
 802    will return to ARM or Thumb code.  Return 0 if it is not a
 803    rt_sigreturn/sigreturn syscall.  */
 804 static int
 805 arm_linux_sigreturn_return_addr (struct frame_info *frame,
 806                                  unsigned long svc_number,
 807                                  CORE_ADDR *pc, int *is_thumb)
 808 {
 809   /* Is this a sigreturn or rt_sigreturn syscall?  */
 810   if (svc_number == 119 || svc_number == 173)
 811     {
 812       if (get_frame_type (frame) == SIGTRAMP_FRAME)
 813         {
 814           ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame));
 815           CORE_ADDR cpsr
 816             = frame_unwind_register_unsigned (frame, ARM_PS_REGNUM);
 817
 818           *is_thumb = (cpsr & t_bit) != 0;
 819           *pc = frame_unwind_caller_pc (frame);
 820           return 1;
 821         }
 822     }
 823   return 0;
 824 }
 825
 826 /* At a ptrace syscall-stop, return the syscall number.  This either
 827    comes from the SWI instruction (OABI) or from r7 (EABI).
 828
 829    When the function fails, it should return -1.  */
 830
 831 static LONGEST
 832 arm_linux_get_syscall_number (struct gdbarch *gdbarch,
 833                               ptid_t ptid)
 834 {
 835   struct regcache *regs = get_thread_regcache (ptid);
 836   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 837
 838   ULONGEST pc;
 839   ULONGEST cpsr;
 840   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
 841   int is_thumb;
 842   ULONGEST svc_number = -1;
 843
 844   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc);
 845   regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr);
 846   is_thumb = (cpsr & t_bit) != 0;
 847
 848   if (is_thumb)
 849     {
 850       regcache_cooked_read_unsigned (regs, 7, &svc_number);
 851     }
 852   else
 853     {
 854       enum bfd_endian byte_order_for_code =
 855         gdbarch_byte_order_for_code (gdbarch);
 856
 857       /* PC gets incremented before the syscall-stop, so read the
 858          previous instruction.  */
 859       unsigned long this_instr =
 860         read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);
 861
 862       unsigned long svc_operand = (0x00ffffff & this_instr);
 863
 864       if (svc_operand)
 865         {
 866           /* OABI */
 867           svc_number = svc_operand - 0x900000;
 868         }
 869       else
 870         {
 871           /* EABI */
 872           regcache_cooked_read_unsigned (regs, 7, &svc_number);
 873         }
 874     }
 875
 876   return svc_number;
 877 }
 878
 879 /* When FRAME is at a syscall instruction, return the PC of the next
 880    instruction to be executed.  */
 881
 882 static CORE_ADDR
 883 arm_linux_syscall_next_pc (struct frame_info *frame)
 884 {
 885   CORE_ADDR pc = get_frame_pc (frame);
 886   CORE_ADDR return_addr = 0;
 887   int is_thumb = arm_frame_is_thumb (frame);
 888   ULONGEST svc_number = 0;
 889
 890   if (is_thumb)
 891     {
 892       svc_number = get_frame_register_unsigned (frame, 7);
 893       return_addr = pc + 2;
 894     }
 895   else
 896     {
 897       struct gdbarch *gdbarch = get_frame_arch (frame);
 898       enum bfd_endian byte_order_for_code =
 899         gdbarch_byte_order_for_code (gdbarch);
 900       unsigned long this_instr =
 901         read_memory_unsigned_integer (pc, 4, byte_order_for_code);
 902
 903       unsigned long svc_operand = (0x00ffffff & this_instr);
 904       if (svc_operand)  /* OABI.  */
 905         {
 906           svc_number = svc_operand - 0x900000;
 907         }
 908       else /* EABI.  */
 909         {
 910           svc_number = get_frame_register_unsigned (frame, 7);
 911         }
 912
 913       return_addr = pc + 4;
 914     }
 915
 916   arm_linux_sigreturn_return_addr (frame, svc_number, &return_addr, &is_thumb);
 917
 918   /* Addresses for calling Thumb functions have the bit 0 set.  */
 919   if (is_thumb)
 920     return_addr |= 1;
 921
 922   return return_addr;
 923 }
 924
 925
 926 /* Insert a single step breakpoint at the next executed instruction.  */
 927
 928 static int
 929 arm_linux_software_single_step (struct frame_info *frame)
 930 {
 931   struct gdbarch *gdbarch = get_frame_arch (frame);
 932   struct address_space *aspace = get_frame_address_space (frame);
 933   CORE_ADDR next_pc;
 934
 935   if (arm_deal_with_atomic_sequence (frame))
 936     return 1;
 937
 938   next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
 939
 940   /* The Linux kernel offers some user-mode helpers in a high page.  We can
 941      not read this page (as of 2.6.23), and even if we could then we couldn't
 942      set breakpoints in it, and even if we could then the atomic operations
 943      would fail when interrupted.  They are all called as functions and return
 944      to the address in LR, so step to there instead.  */
 945   if (next_pc > 0xffff0000)
 946     next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
 947
 948   arm_insert_single_step_breakpoint (gdbarch, aspace, next_pc);
 949
 950   return 1;
 951 }
 952
 953 /* Support for displaced stepping of Linux SVC instructions.  */
 954
 955 static void
 956 arm_linux_cleanup_svc (struct gdbarch *gdbarch,
 957                        struct regcache *regs,
 958                        struct displaced_step_closure *dsc)
 959 {
 960   CORE_ADDR from = dsc->insn_addr;
 961   ULONGEST apparent_pc;
 962   int within_scratch;
 963
 964   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
 965
 966   within_scratch = (apparent_pc >= dsc->scratch_base
 967                     && apparent_pc < (dsc->scratch_base
 968                                       + DISPLACED_MODIFIED_INSNS * 4 + 4));
 969
 970   if (debug_displaced)
 971     {
 972       fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
 973                           "SVC step ", (unsigned long) apparent_pc);
 974       if (within_scratch)
 975         fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
 976       else
 977         fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
 978     }
 979
 980   if (within_scratch)
 981     displaced_write_reg (regs, dsc, ARM_PC_REGNUM, from + 4, BRANCH_WRITE_PC);
 982 }
 983
 984 static int
 985 arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
 986                     struct displaced_step_closure *dsc)
 987 {
 988   CORE_ADDR return_to = 0;
 989
 990   struct frame_info *frame;
 991   unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
 992   int is_sigreturn = 0;
 993   int is_thumb;
 994
 995   frame = get_current_frame ();
 996
 997   is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
 998                                                  &return_to, &is_thumb);
 999   if (is_sigreturn)
1000     {
1001           struct symtab_and_line sal;
1002
1003           if (debug_displaced)
1004             fprintf_unfiltered (gdb_stdlog, "displaced: found "
1005               "sigreturn/rt_sigreturn SVC call.  PC in frame = %lx\n",
1006               (unsigned long) get_frame_pc (frame));
1007
1008           if (debug_displaced)
1009             fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx.  "
1010               "Setting momentary breakpoint.\n", (unsigned long) return_to);
1011
1012           gdb_assert (inferior_thread ()->control.step_resume_breakpoint
1013                       == NULL);
1014
1015           sal = find_pc_line (return_to, 0);
1016           sal.pc = return_to;
1017           sal.section = find_pc_overlay (return_to);
1018           sal.explicit_pc = 1;
1019
1020           frame = get_prev_frame (frame);
1021
1022           if (frame)
1023             {
1024               inferior_thread ()->control.step_resume_breakpoint
1025                 = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
1026                                             bp_step_resume);
1027
1028               /* set_momentary_breakpoint invalidates FRAME.  */
1029               frame = NULL;
1030
1031               /* We need to make sure we actually insert the momentary
1032                  breakpoint set above.  */
1033               insert_breakpoints ();
1034             }
1035           else if (debug_displaced)
1036             fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
1037                                 "frame to set momentary breakpoint for "
1038                                 "sigreturn/rt_sigreturn\n");
1039         }
1040       else if (debug_displaced)
1041         fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
1042                             "SVC call not in signal trampoline frame\n");
1043
1044
1045   /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1046                   location, else nothing.
1047      Insn: unmodified svc.
1048      Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
1049               else leave pc alone.  */
1050
1051
1052   dsc->cleanup = &arm_linux_cleanup_svc;
1053   /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1054      instruction.  */
1055   dsc->wrote_to_pc = 1;
1056
1057   return 0;
1058 }
1059
1060
1061 /* The following two functions implement single-stepping over calls to Linux
1062    kernel helper routines, which perform e.g. atomic operations on architecture
1063    variants which don't support them natively.
1064
1065    When this function is called, the PC will be pointing at the kernel helper
1066    (at an address inaccessible to GDB), and r14 will point to the return
1067    address.  Displaced stepping always executes code in the copy area:
1068    so, make the copy-area instruction branch back to the kernel helper (the
1069    "from" address), and make r14 point to the breakpoint in the copy area.  In
1070    that way, we regain control once the kernel helper returns, and can clean
1071    up appropriately (as if we had just returned from the kernel helper as it
1072    would have been called from the non-displaced location).  */
1073
1074 static void
1075 cleanup_kernel_helper_return (struct gdbarch *gdbarch,
1076                               struct regcache *regs,
1077                               struct displaced_step_closure *dsc)
1078 {
1079   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
1080   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
1081 }
1082
1083 static void
1084 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
1085                                 CORE_ADDR to, struct regcache *regs,
1086                                 struct displaced_step_closure *dsc)
1087 {
1088   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1089
1090   dsc->numinsns = 1;
1091   dsc->insn_addr = from;
1092   dsc->cleanup = &cleanup_kernel_helper_return;
1093   /* Say we wrote to the PC, else cleanup will set PC to the next
1094      instruction in the helper, which isn't helpful.  */
1095   dsc->wrote_to_pc = 1;
1096
1097   /* Preparation: tmp[0] <- r14
1098                   r14 <- <scratch space>+4
1099                   *(<scratch space>+8) <- from
1100      Insn: ldr pc, [r14, #4]
1101      Cleanup: r14 <- tmp[0], pc <- tmp[0].  */
1102
1103   dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM);
1104   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
1105                        CANNOT_WRITE_PC);
1106   write_memory_unsigned_integer (to + 8, 4, byte_order, from);
1107
1108   dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
1109 }
1110
1111 /* Linux-specific displaced step instruction copying function.  Detects when
1112    the program has stepped into a Linux kernel helper routine (which must be
1113    handled as a special case), falling back to arm_displaced_step_copy_insn()
1114    if it hasn't.  */
1115
1116 static struct displaced_step_closure *
1117 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
1118                                     CORE_ADDR from, CORE_ADDR to,
1119                                     struct regcache *regs)
1120 {
1121   struct displaced_step_closure *dsc
1122     = xmalloc (sizeof (struct displaced_step_closure));
1123
1124   /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1125      stop at the return location.  */
1126   if (from > 0xffff0000)
1127     {
1128       if (debug_displaced)
1129         fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
1130                             "at %.8lx\n", (unsigned long) from);
1131
1132       arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
1133     }
1134   else
1135     {
1136       /* Override the default handling of SVC instructions.  */
1137       dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
1138
1139       arm_process_displaced_insn (gdbarch, from, to, regs, dsc);
1140     }
1141
1142   arm_displaced_init_closure (gdbarch, from, to, dsc);
1143
1144   return dsc;
1145 }
1146
1147 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1148    gdbarch.h.  */
1149
1150 static int
1151 arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
1152 {
1153   return (*s == '#' || *s == '$' || isdigit (*s) /* Literal number.  */
1154           || *s == '[' /* Register indirection or
1155                           displacement.  */
1156           || isalpha (*s)); /* Register value.  */
1157 }
1158
1159 /* This routine is used to parse a special token in ARM's assembly.
1160
1161    The special tokens parsed by it are:
1162
1163       - Register displacement (e.g, [fp, #-8])
1164
1165    It returns one if the special token has been parsed successfully,
1166    or zero if the current token is not considered special.  */
1167
1168 static int
1169 arm_stap_parse_special_token (struct gdbarch *gdbarch,
1170                               struct stap_parse_info *p)
1171 {
1172   if (*p->arg == '[')
1173     {
1174       /* Temporary holder for lookahead.  */
1175       const char *tmp = p->arg;
1176       char *endp;
1177       /* Used to save the register name.  */
1178       const char *start;
1179       char *regname;
1180       int len, offset;
1181       int got_minus = 0;
1182       long displacement;
1183       struct stoken str;
1184
1185       ++tmp;
1186       start = tmp;
1187
1188       /* Register name.  */
1189       while (isalnum (*tmp))
1190         ++tmp;
1191
1192       if (*tmp != ',')
1193         return 0;
1194
1195       len = tmp - start;
1196       regname = alloca (len + 2);
1197
1198       offset = 0;
1199       if (isdigit (*start))
1200         {
1201           /* If we are dealing with a register whose name begins with a
1202              digit, it means we should prefix the name with the letter
1203              `r', because GDB expects this name pattern.  Otherwise (e.g.,
1204              we are dealing with the register `fp'), we don't need to
1205              add such a prefix.  */
1206           regname[0] = 'r';
1207           offset = 1;
1208         }
1209
1210       strncpy (regname + offset, start, len);
1211       len += offset;
1212       regname[len] = '\0';
1213
1214       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
1215         error (_("Invalid register name `%s' on expression `%s'."),
1216                regname, p->saved_arg);
1217
1218       ++tmp;
1219       tmp = skip_spaces_const (tmp);
1220       if (*tmp == '#' || *tmp == '$')
1221         ++tmp;
1222
1223       if (*tmp == '-')
1224         {
1225           ++tmp;
1226           got_minus = 1;
1227         }
1228
1229       displacement = strtol (tmp, &endp, 10);
1230       tmp = endp;
1231
1232       /* Skipping last `]'.  */
1233       if (*tmp++ != ']')
1234         return 0;
1235
1236       /* The displacement.  */
1237       write_exp_elt_opcode (&p->pstate, OP_LONG);
1238       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
1239       write_exp_elt_longcst (&p->pstate, displacement);
1240       write_exp_elt_opcode (&p->pstate, OP_LONG);
1241       if (got_minus)
1242         write_exp_elt_opcode (&p->pstate, UNOP_NEG);
1243
1244       /* The register name.  */
1245       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1246       str.ptr = regname;
1247       str.length = len;
1248       write_exp_string (&p->pstate, str);
1249       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1250
1251       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
1252
1253       /* Casting to the expected type.  */
1254       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1255       write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
1256       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1257
1258       write_exp_elt_opcode (&p->pstate, UNOP_IND);
1259
1260       p->arg = tmp;
1261     }
1262   else
1263     return 0;
1264
1265   return 1;
1266 }
1267
1268 /* ARM process record-replay constructs: syscall, signal etc.  */
1269
1270 struct linux_record_tdep arm_linux_record_tdep;
1271
1272 /* arm_canonicalize_syscall maps from the native arm Linux set
1273    of syscall ids into a canonical set of syscall ids used by
1274    process record.  */
1275
1276 static enum gdb_syscall
1277 arm_canonicalize_syscall (int syscall)
1278 {
1279   enum { sys_process_vm_writev = 377 };
1280
1281   if (syscall <= gdb_sys_sched_getaffinity)
1282     return syscall;
1283   else if (syscall >= 243 && syscall <= 247)
1284     return syscall + 2;
1285   else if (syscall >= 248 && syscall <= 253)
1286     return syscall + 4;
1287
1288   return -1;
1289 }
1290
1291 /* Record all registers but PC register for process-record.  */
1292
1293 static int
1294 arm_all_but_pc_registers_record (struct regcache *regcache)
1295 {
1296   int i;
1297
1298   for (i = 0; i < ARM_PC_REGNUM; i++)
1299     {
1300       if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i))
1301         return -1;
1302     }
1303
1304   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1305     return -1;
1306
1307   return 0;
1308 }
1309
1310 /* Handler for arm system call instruction recording.  */
1311
1312 static int
1313 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number)
1314 {
1315   int ret = 0;
1316   enum gdb_syscall syscall_gdb;
1317
1318   syscall_gdb = arm_canonicalize_syscall (svc_number);
1319
1320   if (syscall_gdb < 0)
1321     {
1322       printf_unfiltered (_("Process record and replay target doesn't "
1323                            "support syscall number %s\n"),
1324                            plongest (svc_number));
1325       return -1;
1326     }
1327
1328   if (syscall_gdb == gdb_sys_sigreturn
1329       || syscall_gdb == gdb_sys_rt_sigreturn)
1330    {
1331      if (arm_all_but_pc_registers_record (regcache))
1332        return -1;
1333      return 0;
1334    }
1335
1336   ret = record_linux_system_call (syscall_gdb, regcache,
1337                                   &arm_linux_record_tdep);
1338   if (ret != 0)
1339     return ret;
1340
1341   /* Record the return value of the system call.  */
1342   if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM))
1343     return -1;
1344   /* Record LR.  */
1345   if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM))
1346     return -1;
1347   /* Record CPSR.  */
1348   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1349     return -1;
1350
1351   return 0;
1352 }
1353
1354 /* Implement the skip_trampoline_code gdbarch method.  */
1355
1356 static CORE_ADDR
1357 arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1358 {
1359   CORE_ADDR target_pc = arm_skip_stub (frame, pc);
1360
1361   if (target_pc != 0)
1362     return target_pc;
1363
1364   return find_solib_trampoline_target (frame, pc);
1365 }
1366
1367 static void
1368 arm_linux_init_abi (struct gdbarch_info info,
1369                     struct gdbarch *gdbarch)
1370 {
1371   static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL };
1372   static const char *const stap_register_prefixes[] = { "r", NULL };
1373   static const char *const stap_register_indirection_prefixes[] = { "[",
1374                                                                     NULL };
1375   static const char *const stap_register_indirection_suffixes[] = { "]",
1376                                                                     NULL };
1377   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1378
1379   linux_init_abi (info, gdbarch);
1380
1381   tdep->lowest_pc = 0x8000;
1382   if (info.byte_order == BFD_ENDIAN_BIG)
1383     {
1384       if (tdep->arm_abi == ARM_ABI_AAPCS)
1385         tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
1386       else
1387         tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
1388       tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
1389       tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
1390     }
1391   else
1392     {
1393       if (tdep->arm_abi == ARM_ABI_AAPCS)
1394         tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
1395       else
1396         tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
1397       tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
1398       tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
1399     }
1400   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
1401   tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
1402   tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);
1403
1404   if (tdep->fp_model == ARM_FLOAT_AUTO)
1405     tdep->fp_model = ARM_FLOAT_FPA;
1406
1407   switch (tdep->fp_model)
1408     {
1409     case ARM_FLOAT_FPA:
1410       tdep->jb_pc = ARM_LINUX_JB_PC_FPA;
1411       break;
1412     case ARM_FLOAT_SOFT_FPA:
1413     case ARM_FLOAT_SOFT_VFP:
1414     case ARM_FLOAT_VFP:
1415       tdep->jb_pc = ARM_LINUX_JB_PC_EABI;
1416       break;
1417     default:
1418       internal_error
1419         (__FILE__, __LINE__,
1420          _("arm_linux_init_abi: Floating point model not supported"));
1421       break;
1422     }
1423   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
1424
1425   set_solib_svr4_fetch_link_map_offsets
1426     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
1427
1428   /* Single stepping.  */
1429   set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
1430
1431   /* Shared library handling.  */
1432   set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code);
1433   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1434
1435   /* Enable TLS support.  */
1436   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1437                                              svr4_fetch_objfile_link_map);
1438
1439   tramp_frame_prepend_unwinder (gdbarch,
1440                                 &arm_linux_sigreturn_tramp_frame);
1441   tramp_frame_prepend_unwinder (gdbarch,
1442                                 &arm_linux_rt_sigreturn_tramp_frame);
1443   tramp_frame_prepend_unwinder (gdbarch,
1444                                 &arm_eabi_linux_sigreturn_tramp_frame);
1445   tramp_frame_prepend_unwinder (gdbarch,
1446                                 &arm_eabi_linux_rt_sigreturn_tramp_frame);
1447   tramp_frame_prepend_unwinder (gdbarch,
1448                                 &thumb2_eabi_linux_sigreturn_tramp_frame);
1449   tramp_frame_prepend_unwinder (gdbarch,
1450                                 &thumb2_eabi_linux_rt_sigreturn_tramp_frame);
1451   tramp_frame_prepend_unwinder (gdbarch,
1452                                 &arm_linux_restart_syscall_tramp_frame);
1453   tramp_frame_prepend_unwinder (gdbarch,
1454                                 &arm_kernel_linux_restart_syscall_tramp_frame);
1455
1456   /* Core file support.  */
1457   set_gdbarch_regset_from_core_section (gdbarch,
1458                                         arm_linux_regset_from_core_section);
1459   set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description);
1460
1461   if (tdep->have_vfp_registers)
1462     set_gdbarch_core_regset_sections (gdbarch, arm_linux_vfp_regset_sections);
1463   else if (tdep->have_fpa_registers)
1464     set_gdbarch_core_regset_sections (gdbarch, arm_linux_fpa_regset_sections);
1465
1466   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
1467
1468   /* Displaced stepping.  */
1469   set_gdbarch_displaced_step_copy_insn (gdbarch,
1470                                         arm_linux_displaced_step_copy_insn);
1471   set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
1472   set_gdbarch_displaced_step_free_closure (gdbarch,
1473                                            simple_displaced_step_free_closure);
1474   set_gdbarch_displaced_step_location (gdbarch, displaced_step_at_entry_point);
1475
1476   /* Reversible debugging, process record.  */
1477   set_gdbarch_process_record (gdbarch, arm_process_record);
1478
1479   /* SystemTap functions.  */
1480   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1481   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1482   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
1483                                           stap_register_indirection_prefixes);
1484   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
1485                                           stap_register_indirection_suffixes);
1486   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
1487   set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand);
1488   set_gdbarch_stap_parse_special_token (gdbarch,
1489                                         arm_stap_parse_special_token);
1490
1491   tdep->syscall_next_pc = arm_linux_syscall_next_pc;
1492
1493   /* `catch syscall' */
1494   set_xml_syscall_file_name ("syscalls/arm-linux.xml");
1495   set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number);
1496
1497   /* Syscall record.  */
1498   tdep->arm_syscall_record = arm_linux_syscall_record;
1499
1500   /* Initialize the arm_linux_record_tdep.  */
1501   /* These values are the size of the type that will be used in a system
1502      call.  They are obtained from Linux Kernel source.  */
1503   arm_linux_record_tdep.size_pointer
1504     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1505   arm_linux_record_tdep.size__old_kernel_stat = 32;
1506   arm_linux_record_tdep.size_tms = 16;
1507   arm_linux_record_tdep.size_loff_t = 8;
1508   arm_linux_record_tdep.size_flock = 16;
1509   arm_linux_record_tdep.size_oldold_utsname = 45;
1510   arm_linux_record_tdep.size_ustat = 20;
1511   arm_linux_record_tdep.size_old_sigaction = 140;
1512   arm_linux_record_tdep.size_old_sigset_t = 128;
1513   arm_linux_record_tdep.size_rlimit = 8;
1514   arm_linux_record_tdep.size_rusage = 72;
1515   arm_linux_record_tdep.size_timeval = 8;
1516   arm_linux_record_tdep.size_timezone = 8;
1517   arm_linux_record_tdep.size_old_gid_t = 2;
1518   arm_linux_record_tdep.size_old_uid_t = 2;
1519   arm_linux_record_tdep.size_fd_set = 128;
1520   arm_linux_record_tdep.size_dirent = 268;
1521   arm_linux_record_tdep.size_dirent64 = 276;
1522   arm_linux_record_tdep.size_statfs = 64;
1523   arm_linux_record_tdep.size_statfs64 = 84;
1524   arm_linux_record_tdep.size_sockaddr = 16;
1525   arm_linux_record_tdep.size_int
1526     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1527   arm_linux_record_tdep.size_long
1528     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1529   arm_linux_record_tdep.size_ulong
1530     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1531   arm_linux_record_tdep.size_msghdr = 28;
1532   arm_linux_record_tdep.size_itimerval = 16;
1533   arm_linux_record_tdep.size_stat = 88;
1534   arm_linux_record_tdep.size_old_utsname = 325;
1535   arm_linux_record_tdep.size_sysinfo = 64;
1536   arm_linux_record_tdep.size_msqid_ds = 88;
1537   arm_linux_record_tdep.size_shmid_ds = 84;
1538   arm_linux_record_tdep.size_new_utsname = 390;
1539   arm_linux_record_tdep.size_timex = 128;
1540   arm_linux_record_tdep.size_mem_dqinfo = 24;
1541   arm_linux_record_tdep.size_if_dqblk = 68;
1542   arm_linux_record_tdep.size_fs_quota_stat = 68;
1543   arm_linux_record_tdep.size_timespec = 8;
1544   arm_linux_record_tdep.size_pollfd = 8;
1545   arm_linux_record_tdep.size_NFS_FHSIZE = 32;
1546   arm_linux_record_tdep.size_knfsd_fh = 132;
1547   arm_linux_record_tdep.size_TASK_COMM_LEN = 16;
1548   arm_linux_record_tdep.size_sigaction = 140;
1549   arm_linux_record_tdep.size_sigset_t = 8;
1550   arm_linux_record_tdep.size_siginfo_t = 128;
1551   arm_linux_record_tdep.size_cap_user_data_t = 12;
1552   arm_linux_record_tdep.size_stack_t = 12;
1553   arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long;
1554   arm_linux_record_tdep.size_stat64 = 96;
1555   arm_linux_record_tdep.size_gid_t = 2;
1556   arm_linux_record_tdep.size_uid_t = 2;
1557   arm_linux_record_tdep.size_PAGE_SIZE = 4096;
1558   arm_linux_record_tdep.size_flock64 = 24;
1559   arm_linux_record_tdep.size_user_desc = 16;
1560   arm_linux_record_tdep.size_io_event = 32;
1561   arm_linux_record_tdep.size_iocb = 64;
1562   arm_linux_record_tdep.size_epoll_event = 12;
1563   arm_linux_record_tdep.size_itimerspec
1564     = arm_linux_record_tdep.size_timespec * 2;
1565   arm_linux_record_tdep.size_mq_attr = 32;
1566   arm_linux_record_tdep.size_siginfo = 128;
1567   arm_linux_record_tdep.size_termios = 36;
1568   arm_linux_record_tdep.size_termios2 = 44;
1569   arm_linux_record_tdep.size_pid_t = 4;
1570   arm_linux_record_tdep.size_winsize = 8;
1571   arm_linux_record_tdep.size_serial_struct = 60;
1572   arm_linux_record_tdep.size_serial_icounter_struct = 80;
1573   arm_linux_record_tdep.size_hayes_esp_config = 12;
1574   arm_linux_record_tdep.size_size_t = 4;
1575   arm_linux_record_tdep.size_iovec = 8;
1576
1577   /* These values are the second argument of system call "sys_ioctl".
1578      They are obtained from Linux Kernel source.  */
1579   arm_linux_record_tdep.ioctl_TCGETS = 0x5401;
1580   arm_linux_record_tdep.ioctl_TCSETS = 0x5402;
1581   arm_linux_record_tdep.ioctl_TCSETSW = 0x5403;
1582   arm_linux_record_tdep.ioctl_TCSETSF = 0x5404;
1583   arm_linux_record_tdep.ioctl_TCGETA = 0x5405;
1584   arm_linux_record_tdep.ioctl_TCSETA = 0x5406;
1585   arm_linux_record_tdep.ioctl_TCSETAW = 0x5407;
1586   arm_linux_record_tdep.ioctl_TCSETAF = 0x5408;
1587   arm_linux_record_tdep.ioctl_TCSBRK = 0x5409;
1588   arm_linux_record_tdep.ioctl_TCXONC = 0x540a;
1589   arm_linux_record_tdep.ioctl_TCFLSH = 0x540b;
1590   arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
1591   arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
1592   arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
1593   arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
1594   arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
1595   arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
1596   arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
1597   arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
1598   arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
1599   arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
1600   arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
1601   arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
1602   arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
1603   arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
1604   arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
1605   arm_linux_record_tdep.ioctl_FIONREAD = 0x541b;
1606   arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD;
1607   arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
1608   arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
1609   arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
1610   arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
1611   arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
1612   arm_linux_record_tdep.ioctl_FIONBIO = 0x5421;
1613   arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
1614   arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
1615   arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
1616   arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
1617   arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
1618   arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
1619   arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
1620   arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
1621   arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1622   arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1623   arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
1624   arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1625   arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1626   arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1627   arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1628   arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1629   arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1630   arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1631   arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1632   arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1633   arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1634   arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1635   arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1636   arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1637   arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
1638   arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
1639   arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
1640   arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
1641   arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
1642   arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
1643   arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1644
1645   /* These values are the second argument of system call "sys_fcntl"
1646      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1647   arm_linux_record_tdep.fcntl_F_GETLK = 5;
1648   arm_linux_record_tdep.fcntl_F_GETLK64 = 12;
1649   arm_linux_record_tdep.fcntl_F_SETLK64 = 13;
1650   arm_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1651
1652   arm_linux_record_tdep.arg1 = ARM_A1_REGNUM + 1;
1653   arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 2;
1654   arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 3;
1655   arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3;
1656 }
1657
1658 /* Provide a prototype to silence -Wmissing-prototypes.  */
1659 extern initialize_file_ftype _initialize_arm_linux_tdep;
1660
1661 void
1662 _initialize_arm_linux_tdep (void)
1663 {
1664   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
1665                           arm_linux_init_abi);
1666 }