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 /* Operation function pointers for get_next_pcs.  */
 269 static struct arm_get_next_pcs_ops arm_linux_get_next_pcs_ops = {
 270   arm_get_next_pcs_read_memory_unsigned_integer,
 271   arm_get_next_pcs_syscall_next_pc,
 272   arm_get_next_pcs_addr_bits_remove,
 273   arm_get_next_pcs_is_thumb
 274 };
 275
 276 static void
 277 arm_linux_sigtramp_cache (struct frame_info *this_frame,
 278                           struct trad_frame_cache *this_cache,
 279                           CORE_ADDR func, int regs_offset)
 280 {
 281   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 282   CORE_ADDR base = sp + regs_offset;
 283   int i;
 284
 285   for (i = 0; i < 16; i++)
 286     trad_frame_set_reg_addr (this_cache, i, base + i * 4);
 287
 288   trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
 289
 290   /* The VFP or iWMMXt registers may be saved on the stack, but there's
 291      no reliable way to restore them (yet).  */
 292
 293   /* Save a frame ID.  */
 294   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 295 }
 296
 297 /* See arm-linux.h for stack layout details.  */
 298 static void
 299 arm_linux_sigreturn_init (const struct tramp_frame *self,
 300                           struct frame_info *this_frame,
 301                           struct trad_frame_cache *this_cache,
 302                           CORE_ADDR func)
 303 {
 304   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 305   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 306   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 307   ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
 308
 309   if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
 310     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 311                               ARM_UCONTEXT_SIGCONTEXT
 312                               + ARM_SIGCONTEXT_R0);
 313   else
 314     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 315                               ARM_SIGCONTEXT_R0);
 316 }
 317
 318 static void
 319 arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
 320                           struct frame_info *this_frame,
 321                           struct trad_frame_cache *this_cache,
 322                           CORE_ADDR func)
 323 {
 324   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 325   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 326   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 327   ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
 328
 329   if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
 330     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 331                               ARM_OLD_RT_SIGFRAME_UCONTEXT
 332                               + ARM_UCONTEXT_SIGCONTEXT
 333                               + ARM_SIGCONTEXT_R0);
 334   else
 335     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 336                               ARM_NEW_RT_SIGFRAME_UCONTEXT
 337                               + ARM_UCONTEXT_SIGCONTEXT
 338                               + ARM_SIGCONTEXT_R0);
 339 }
 340
 341 static void
 342 arm_linux_restart_syscall_init (const struct tramp_frame *self,
 343                                 struct frame_info *this_frame,
 344                                 struct trad_frame_cache *this_cache,
 345                                 CORE_ADDR func)
 346 {
 347   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 348   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 349   CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4);
 350   CORE_ADDR cpsr = get_frame_register_unsigned (this_frame, ARM_PS_REGNUM);
 351   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
 352   int sp_offset;
 353
 354   /* There are two variants of this trampoline; with older kernels, the
 355      stub is placed on the stack, while newer kernels use the stub from
 356      the vector page.  They are identical except that the older version
 357      increments SP by 12 (to skip stored PC and the stub itself), while
 358      the newer version increments SP only by 4 (just the stored PC).  */
 359   if (self->insn[1].bytes == ARM_LDR_PC_SP_4)
 360     sp_offset = 4;
 361   else
 362     sp_offset = 12;
 363
 364   /* Update Thumb bit in CPSR.  */
 365   if (pc & 1)
 366     cpsr |= t_bit;
 367   else
 368     cpsr &= ~t_bit;
 369
 370   /* Remove Thumb bit from PC.  */
 371   pc = gdbarch_addr_bits_remove (gdbarch, pc);
 372
 373   /* Save previous register values.  */
 374   trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset);
 375   trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc);
 376   trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr);
 377
 378   /* Save a frame ID.  */
 379   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 380 }
 381
 382 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
 383   SIGTRAMP_FRAME,
 384   4,
 385   {
 386     { ARM_LINUX_SIGRETURN_INSTR, -1 },
 387     { TRAMP_SENTINEL_INSN }
 388   },
 389   arm_linux_sigreturn_init
 390 };
 391
 392 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
 393   SIGTRAMP_FRAME,
 394   4,
 395   {
 396     { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
 397     { TRAMP_SENTINEL_INSN }
 398   },
 399   arm_linux_rt_sigreturn_init
 400 };
 401
 402 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
 403   SIGTRAMP_FRAME,
 404   4,
 405   {
 406     { ARM_SET_R7_SIGRETURN, -1 },
 407     { ARM_EABI_SYSCALL, -1 },
 408     { TRAMP_SENTINEL_INSN }
 409   },
 410   arm_linux_sigreturn_init
 411 };
 412
 413 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
 414   SIGTRAMP_FRAME,
 415   4,
 416   {
 417     { ARM_SET_R7_RT_SIGRETURN, -1 },
 418     { ARM_EABI_SYSCALL, -1 },
 419     { TRAMP_SENTINEL_INSN }
 420   },
 421   arm_linux_rt_sigreturn_init
 422 };
 423
 424 static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = {
 425   SIGTRAMP_FRAME,
 426   2,
 427   {
 428     { THUMB2_SET_R7_SIGRETURN1, -1 },
 429     { THUMB2_SET_R7_SIGRETURN2, -1 },
 430     { THUMB2_EABI_SYSCALL, -1 },
 431     { TRAMP_SENTINEL_INSN }
 432   },
 433   arm_linux_sigreturn_init
 434 };
 435
 436 static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = {
 437   SIGTRAMP_FRAME,
 438   2,
 439   {
 440     { THUMB2_SET_R7_RT_SIGRETURN1, -1 },
 441     { THUMB2_SET_R7_RT_SIGRETURN2, -1 },
 442     { THUMB2_EABI_SYSCALL, -1 },
 443     { TRAMP_SENTINEL_INSN }
 444   },
 445   arm_linux_rt_sigreturn_init
 446 };
 447
 448 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
 449   NORMAL_FRAME,
 450   4,
 451   {
 452     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
 453     { ARM_LDR_PC_SP_12, -1 },
 454     { TRAMP_SENTINEL_INSN }
 455   },
 456   arm_linux_restart_syscall_init
 457 };
 458
 459 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
 460   NORMAL_FRAME,
 461   4,
 462   {
 463     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
 464     { ARM_LDR_PC_SP_4, -1 },
 465     { TRAMP_SENTINEL_INSN }
 466   },
 467   arm_linux_restart_syscall_init
 468 };
 469
 470 /* Core file and register set support.  */
 471
 472 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
 473
 474 void
 475 arm_linux_supply_gregset (const struct regset *regset,
 476                           struct regcache *regcache,
 477                           int regnum, const void *gregs_buf, size_t len)
 478 {
 479   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 480   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 481   const gdb_byte *gregs = (const gdb_byte *) gregs_buf;
 482   int regno;
 483   CORE_ADDR reg_pc;
 484   gdb_byte pc_buf[INT_REGISTER_SIZE];
 485
 486   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 487     if (regnum == -1 || regnum == regno)
 488       regcache_raw_supply (regcache, regno,
 489                            gregs + INT_REGISTER_SIZE * regno);
 490
 491   if (regnum == ARM_PS_REGNUM || regnum == -1)
 492     {
 493       if (arm_apcs_32)
 494         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 495                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 496       else
 497         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 498                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 499     }
 500
 501   if (regnum == ARM_PC_REGNUM || regnum == -1)
 502     {
 503       reg_pc = extract_unsigned_integer (gregs
 504                                          + INT_REGISTER_SIZE * ARM_PC_REGNUM,
 505                                          INT_REGISTER_SIZE, byte_order);
 506       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
 507       store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
 508       regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
 509     }
 510 }
 511
 512 void
 513 arm_linux_collect_gregset (const struct regset *regset,
 514                            const struct regcache *regcache,
 515                            int regnum, void *gregs_buf, size_t len)
 516 {
 517   gdb_byte *gregs = (gdb_byte *) gregs_buf;
 518   int regno;
 519
 520   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 521     if (regnum == -1 || regnum == regno)
 522       regcache_raw_collect (regcache, regno,
 523                             gregs + INT_REGISTER_SIZE * regno);
 524
 525   if (regnum == ARM_PS_REGNUM || regnum == -1)
 526     {
 527       if (arm_apcs_32)
 528         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 529                               gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 530       else
 531         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 532                               gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 533     }
 534
 535   if (regnum == ARM_PC_REGNUM || regnum == -1)
 536     regcache_raw_collect (regcache, ARM_PC_REGNUM,
 537                           gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 538 }
 539
 540 /* Support for register format used by the NWFPE FPA emulator.  */
 541
 542 #define typeNone                0x00
 543 #define typeSingle              0x01
 544 #define typeDouble              0x02
 545 #define typeExtended            0x03
 546
 547 void
 548 supply_nwfpe_register (struct regcache *regcache, int regno,
 549                        const gdb_byte *regs)
 550 {
 551   const gdb_byte *reg_data;
 552   gdb_byte reg_tag;
 553   gdb_byte buf[FP_REGISTER_SIZE];
 554
 555   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 556   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 557   memset (buf, 0, FP_REGISTER_SIZE);
 558
 559   switch (reg_tag)
 560     {
 561     case typeSingle:
 562       memcpy (buf, reg_data, 4);
 563       break;
 564     case typeDouble:
 565       memcpy (buf, reg_data + 4, 4);
 566       memcpy (buf + 4, reg_data, 4);
 567       break;
 568     case typeExtended:
 569       /* We want sign and exponent, then least significant bits,
 570          then most significant.  NWFPE does sign, most, least.  */
 571       memcpy (buf, reg_data, 4);
 572       memcpy (buf + 4, reg_data + 8, 4);
 573       memcpy (buf + 8, reg_data + 4, 4);
 574       break;
 575     default:
 576       break;
 577     }
 578
 579   regcache_raw_supply (regcache, regno, buf);
 580 }
 581
 582 void
 583 collect_nwfpe_register (const struct regcache *regcache, int regno,
 584                         gdb_byte *regs)
 585 {
 586   gdb_byte *reg_data;
 587   gdb_byte reg_tag;
 588   gdb_byte buf[FP_REGISTER_SIZE];
 589
 590   regcache_raw_collect (regcache, regno, buf);
 591
 592   /* NOTE drow/2006-06-07: This code uses the tag already in the
 593      register buffer.  I've preserved that when moving the code
 594      from the native file to the target file.  But this doesn't
 595      always make sense.  */
 596
 597   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 598   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 599
 600   switch (reg_tag)
 601     {
 602     case typeSingle:
 603       memcpy (reg_data, buf, 4);
 604       break;
 605     case typeDouble:
 606       memcpy (reg_data, buf + 4, 4);
 607       memcpy (reg_data + 4, buf, 4);
 608       break;
 609     case typeExtended:
 610       memcpy (reg_data, buf, 4);
 611       memcpy (reg_data + 4, buf + 8, 4);
 612       memcpy (reg_data + 8, buf + 4, 4);
 613       break;
 614     default:
 615       break;
 616     }
 617 }
 618
 619 void
 620 arm_linux_supply_nwfpe (const struct regset *regset,
 621                         struct regcache *regcache,
 622                         int regnum, const void *regs_buf, size_t len)
 623 {
 624   const gdb_byte *regs = (const gdb_byte *) regs_buf;
 625   int regno;
 626
 627   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 628     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 629                          regs + NWFPE_FPSR_OFFSET);
 630
 631   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 632     if (regnum == -1 || regnum == regno)
 633       supply_nwfpe_register (regcache, regno, regs);
 634 }
 635
 636 void
 637 arm_linux_collect_nwfpe (const struct regset *regset,
 638                          const struct regcache *regcache,
 639                          int regnum, void *regs_buf, size_t len)
 640 {
 641   gdb_byte *regs = (gdb_byte *) regs_buf;
 642   int regno;
 643
 644   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 645     if (regnum == -1 || regnum == regno)
 646       collect_nwfpe_register (regcache, regno, regs);
 647
 648   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 649     regcache_raw_collect (regcache, ARM_FPS_REGNUM,
 650                           regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
 651 }
 652
 653 /* Support VFP register format.  */
 654
 655 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
 656
 657 static void
 658 arm_linux_supply_vfp (const struct regset *regset,
 659                       struct regcache *regcache,
 660                       int regnum, const void *regs_buf, size_t len)
 661 {
 662   const gdb_byte *regs = (const gdb_byte *) regs_buf;
 663   int regno;
 664
 665   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
 666     regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
 667
 668   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
 669     if (regnum == -1 || regnum == regno)
 670       regcache_raw_supply (regcache, regno,
 671                            regs + (regno - ARM_D0_REGNUM) * 8);
 672 }
 673
 674 static void
 675 arm_linux_collect_vfp (const struct regset *regset,
 676                          const struct regcache *regcache,
 677                          int regnum, void *regs_buf, size_t len)
 678 {
 679   gdb_byte *regs = (gdb_byte *) regs_buf;
 680   int regno;
 681
 682   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
 683     regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
 684
 685   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
 686     if (regnum == -1 || regnum == regno)
 687       regcache_raw_collect (regcache, regno,
 688                             regs + (regno - ARM_D0_REGNUM) * 8);
 689 }
 690
 691 static const struct regset arm_linux_gregset =
 692   {
 693     NULL, arm_linux_supply_gregset, arm_linux_collect_gregset
 694   };
 695
 696 static const struct regset arm_linux_fpregset =
 697   {
 698     NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe
 699   };
 700
 701 static const struct regset arm_linux_vfpregset =
 702   {
 703     NULL, arm_linux_supply_vfp, arm_linux_collect_vfp
 704   };
 705
 706 /* Iterate over core file register note sections.  */
 707
 708 static void
 709 arm_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
 710                                         iterate_over_regset_sections_cb *cb,
 711                                         void *cb_data,
 712                                         const struct regcache *regcache)
 713 {
 714   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 715
 716   cb (".reg", ARM_LINUX_SIZEOF_GREGSET, &arm_linux_gregset, NULL, cb_data);
 717
 718   if (tdep->vfp_register_count > 0)
 719     cb (".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP, &arm_linux_vfpregset,
 720         "VFP floating-point", cb_data);
 721   else if (tdep->have_fpa_registers)
 722     cb (".reg2", ARM_LINUX_SIZEOF_NWFPE, &arm_linux_fpregset,
 723         "FPA floating-point", cb_data);
 724 }
 725
 726 /* Determine target description from core file.  */
 727
 728 static const struct target_desc *
 729 arm_linux_core_read_description (struct gdbarch *gdbarch,
 730                                  struct target_ops *target,
 731                                  bfd *abfd)
 732 {
 733   CORE_ADDR arm_hwcap = 0;
 734
 735   if (target_auxv_search (target, AT_HWCAP, &arm_hwcap) != 1)
 736     return NULL;
 737
 738   if (arm_hwcap & HWCAP_VFP)
 739     {
 740       /* NEON implies VFPv3-D32 or no-VFP unit.  Say that we only support
 741          Neon with VFPv3-D32.  */
 742       if (arm_hwcap & HWCAP_NEON)
 743         return tdesc_arm_with_neon;
 744       else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
 745         return tdesc_arm_with_vfpv3;
 746       else
 747         return tdesc_arm_with_vfpv2;
 748     }
 749
 750   return NULL;
 751 }
 752
 753
 754 /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
 755    return 1.  In addition, set IS_THUMB depending on whether we
 756    will return to ARM or Thumb code.  Return 0 if it is not a
 757    rt_sigreturn/sigreturn syscall.  */
 758 static int
 759 arm_linux_sigreturn_return_addr (struct frame_info *frame,
 760                                  unsigned long svc_number,
 761                                  CORE_ADDR *pc, int *is_thumb)
 762 {
 763   /* Is this a sigreturn or rt_sigreturn syscall?  */
 764   if (svc_number == 119 || svc_number == 173)
 765     {
 766       if (get_frame_type (frame) == SIGTRAMP_FRAME)
 767         {
 768           ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame));
 769           CORE_ADDR cpsr
 770             = frame_unwind_register_unsigned (frame, ARM_PS_REGNUM);
 771
 772           *is_thumb = (cpsr & t_bit) != 0;
 773           *pc = frame_unwind_caller_pc (frame);
 774           return 1;
 775         }
 776     }
 777   return 0;
 778 }
 779
 780 /* Find the value of the next PC after a sigreturn or rt_sigreturn syscall
 781    based on current processor state.  */
 782 static CORE_ADDR
 783 arm_linux_sigreturn_next_pc (struct regcache *regcache,
 784                              unsigned long svc_number)
 785 {
 786   ULONGEST sp;
 787   unsigned long sp_data;
 788   CORE_ADDR next_pc = 0;
 789   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 790   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 791   int pc_offset = 0;
 792   int is_sigreturn = 0;
 793
 794   gdb_assert (svc_number == ARM_SIGRETURN
 795               || svc_number == ARM_RT_SIGRETURN);
 796
 797   is_sigreturn = (svc_number == ARM_SIGRETURN);
 798   regcache_cooked_read_unsigned (regcache, ARM_SP_REGNUM, &sp);
 799   sp_data = read_memory_unsigned_integer (sp, 4, byte_order);
 800
 801   pc_offset = arm_linux_sigreturn_next_pc_offset (sp, sp_data, svc_number,
 802                                                   is_sigreturn);
 803
 804   next_pc = read_memory_unsigned_integer (sp + pc_offset, 4, byte_order);
 805
 806   return next_pc;
 807 }
 808
 809 /* At a ptrace syscall-stop, return the syscall number.  This either
 810    comes from the SWI instruction (OABI) or from r7 (EABI).
 811
 812    When the function fails, it should return -1.  */
 813
 814 static LONGEST
 815 arm_linux_get_syscall_number (struct gdbarch *gdbarch,
 816                               ptid_t ptid)
 817 {
 818   struct regcache *regs = get_thread_regcache (ptid);
 819   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 820
 821   ULONGEST pc;
 822   ULONGEST cpsr;
 823   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
 824   int is_thumb;
 825   ULONGEST svc_number = -1;
 826
 827   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc);
 828   regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr);
 829   is_thumb = (cpsr & t_bit) != 0;
 830
 831   if (is_thumb)
 832     {
 833       regcache_cooked_read_unsigned (regs, 7, &svc_number);
 834     }
 835   else
 836     {
 837       enum bfd_endian byte_order_for_code =
 838         gdbarch_byte_order_for_code (gdbarch);
 839
 840       /* PC gets incremented before the syscall-stop, so read the
 841          previous instruction.  */
 842       unsigned long this_instr =
 843         read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);
 844
 845       unsigned long svc_operand = (0x00ffffff & this_instr);
 846
 847       if (svc_operand)
 848         {
 849           /* OABI */
 850           svc_number = svc_operand - 0x900000;
 851         }
 852       else
 853         {
 854           /* EABI */
 855           regcache_cooked_read_unsigned (regs, 7, &svc_number);
 856         }
 857     }
 858
 859   return svc_number;
 860 }
 861
 862 /* When the processor is at a syscall instruction, return the PC of the
 863    next instruction to be executed.  */
 864
 865 static CORE_ADDR
 866 arm_linux_syscall_next_pc (struct regcache *regcache)
 867 {
 868   CORE_ADDR pc = regcache_read_pc (regcache);
 869   CORE_ADDR next_pc = 0;
 870   int is_thumb = arm_is_thumb (regcache);
 871   ULONGEST svc_number = 0;
 872   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 873
 874   if (is_thumb)
 875     {
 876       svc_number = regcache_raw_get_unsigned (regcache, 7);
 877       next_pc = pc + 2;
 878     }
 879   else
 880     {
 881       struct gdbarch *gdbarch = get_regcache_arch (regcache);
 882       enum bfd_endian byte_order_for_code =
 883         gdbarch_byte_order_for_code (gdbarch);
 884       unsigned long this_instr =
 885         read_memory_unsigned_integer (pc, 4, byte_order_for_code);
 886
 887       unsigned long svc_operand = (0x00ffffff & this_instr);
 888       if (svc_operand)  /* OABI.  */
 889         {
 890           svc_number = svc_operand - 0x900000;
 891         }
 892       else /* EABI.  */
 893         {
 894           svc_number = regcache_raw_get_unsigned (regcache, 7);
 895         }
 896
 897       next_pc = pc + 4;
 898     }
 899
 900   if (svc_number == ARM_SIGRETURN || svc_number == ARM_RT_SIGRETURN)
 901     next_pc = arm_linux_sigreturn_next_pc (regcache, svc_number);
 902
 903   /* Addresses for calling Thumb functions have the bit 0 set.  */
 904   if (is_thumb)
 905     next_pc = MAKE_THUMB_ADDR (next_pc);
 906
 907   return next_pc;
 908 }
 909
 910
 911 /* Insert a single step breakpoint at the next executed instruction.  */
 912
 913 static int
 914 arm_linux_software_single_step (struct frame_info *frame)
 915 {
 916   struct regcache *regcache = get_current_regcache ();
 917   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 918   struct address_space *aspace = get_regcache_aspace (regcache);
 919   struct arm_get_next_pcs next_pcs_ctx;
 920   CORE_ADDR pc;
 921   int i;
 922   VEC (CORE_ADDR) *next_pcs = NULL;
 923   struct cleanup *old_chain = make_cleanup (VEC_cleanup (CORE_ADDR), &next_pcs);
 924
 925   /* If the target does have hardware single step, GDB doesn't have
 926      to bother software single step.  */
 927   if (target_can_do_single_step () == 1)
 928     return 0;
 929
 930   arm_get_next_pcs_ctor (&next_pcs_ctx,
 931                          &arm_linux_get_next_pcs_ops,
 932                          gdbarch_byte_order (gdbarch),
 933                          gdbarch_byte_order_for_code (gdbarch),
 934                          1,
 935                          regcache);
 936
 937   next_pcs = arm_get_next_pcs (&next_pcs_ctx, regcache_read_pc (regcache));
 938
 939   for (i = 0; VEC_iterate (CORE_ADDR, next_pcs, i, pc); i++)
 940     {
 941       /* The Linux kernel offers some user-mode helpers in a high page.  We can
 942          not read this page (as of 2.6.23), and even if we could then we
 943          couldn't set breakpoints in it, and even if we could then the atomic
 944          operations would fail when interrupted.  They are all called as
 945          functions and return to the address in LR, so step to there
 946          instead.  */
 947       if (pc > 0xffff0000)
 948         pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
 949
 950       arm_insert_single_step_breakpoint (gdbarch, aspace, pc);
 951     }
 952
 953   do_cleanups (old_chain);
 954
 955   return 1;
 956 }
 957
 958 /* Support for displaced stepping of Linux SVC instructions.  */
 959
 960 static void
 961 arm_linux_cleanup_svc (struct gdbarch *gdbarch,
 962                        struct regcache *regs,
 963                        struct displaced_step_closure *dsc)
 964 {
 965   ULONGEST apparent_pc;
 966   int within_scratch;
 967
 968   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
 969
 970   within_scratch = (apparent_pc >= dsc->scratch_base
 971                     && apparent_pc < (dsc->scratch_base
 972                                       + DISPLACED_MODIFIED_INSNS * 4 + 4));
 973
 974   if (debug_displaced)
 975     {
 976       fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
 977                           "SVC step ", (unsigned long) apparent_pc);
 978       if (within_scratch)
 979         fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
 980       else
 981         fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
 982     }
 983
 984   if (within_scratch)
 985     displaced_write_reg (regs, dsc, ARM_PC_REGNUM,
 986                          dsc->insn_addr + dsc->insn_size, BRANCH_WRITE_PC);
 987 }
 988
 989 static int
 990 arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
 991                     struct displaced_step_closure *dsc)
 992 {
 993   CORE_ADDR return_to = 0;
 994
 995   struct frame_info *frame;
 996   unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
 997   int is_sigreturn = 0;
 998   int is_thumb;
 999
1000   frame = get_current_frame ();
1001
1002   is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
1003                                                  &return_to, &is_thumb);
1004   if (is_sigreturn)
1005     {
1006       struct symtab_and_line sal;
1007
1008       if (debug_displaced)
1009         fprintf_unfiltered (gdb_stdlog, "displaced: found "
1010                             "sigreturn/rt_sigreturn SVC call.  PC in "
1011                             "frame = %lx\n",
1012                             (unsigned long) get_frame_pc (frame));
1013
1014       if (debug_displaced)
1015         fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx.  "
1016                             "Setting momentary breakpoint.\n",
1017                             (unsigned long) return_to);
1018
1019       gdb_assert (inferior_thread ()->control.step_resume_breakpoint
1020                   == NULL);
1021
1022       sal = find_pc_line (return_to, 0);
1023       sal.pc = return_to;
1024       sal.section = find_pc_overlay (return_to);
1025       sal.explicit_pc = 1;
1026
1027       frame = get_prev_frame (frame);
1028
1029       if (frame)
1030         {
1031           inferior_thread ()->control.step_resume_breakpoint
1032             = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
1033                                         bp_step_resume);
1034
1035           /* set_momentary_breakpoint invalidates FRAME.  */
1036           frame = NULL;
1037
1038           /* We need to make sure we actually insert the momentary
1039              breakpoint set above.  */
1040           insert_breakpoints ();
1041         }
1042       else if (debug_displaced)
1043         fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
1044                             "frame to set momentary breakpoint for "
1045                             "sigreturn/rt_sigreturn\n");
1046     }
1047   else if (debug_displaced)
1048     fprintf_unfiltered (gdb_stdlog, "displaced: found SVC call\n");
1049
1050   /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1051                   location, else nothing.
1052      Insn: unmodified svc.
1053      Cleanup: if pc lands in scratch space, pc <- insn_addr + insn_size
1054               else leave pc alone.  */
1055
1056
1057   dsc->cleanup = &arm_linux_cleanup_svc;
1058   /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1059      instruction.  */
1060   dsc->wrote_to_pc = 1;
1061
1062   return 0;
1063 }
1064
1065
1066 /* The following two functions implement single-stepping over calls to Linux
1067    kernel helper routines, which perform e.g. atomic operations on architecture
1068    variants which don't support them natively.
1069
1070    When this function is called, the PC will be pointing at the kernel helper
1071    (at an address inaccessible to GDB), and r14 will point to the return
1072    address.  Displaced stepping always executes code in the copy area:
1073    so, make the copy-area instruction branch back to the kernel helper (the
1074    "from" address), and make r14 point to the breakpoint in the copy area.  In
1075    that way, we regain control once the kernel helper returns, and can clean
1076    up appropriately (as if we had just returned from the kernel helper as it
1077    would have been called from the non-displaced location).  */
1078
1079 static void
1080 cleanup_kernel_helper_return (struct gdbarch *gdbarch,
1081                               struct regcache *regs,
1082                               struct displaced_step_closure *dsc)
1083 {
1084   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
1085   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
1086 }
1087
1088 static void
1089 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
1090                                 CORE_ADDR to, struct regcache *regs,
1091                                 struct displaced_step_closure *dsc)
1092 {
1093   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1094
1095   dsc->numinsns = 1;
1096   dsc->insn_addr = from;
1097   dsc->cleanup = &cleanup_kernel_helper_return;
1098   /* Say we wrote to the PC, else cleanup will set PC to the next
1099      instruction in the helper, which isn't helpful.  */
1100   dsc->wrote_to_pc = 1;
1101
1102   /* Preparation: tmp[0] <- r14
1103                   r14 <- <scratch space>+4
1104                   *(<scratch space>+8) <- from
1105      Insn: ldr pc, [r14, #4]
1106      Cleanup: r14 <- tmp[0], pc <- tmp[0].  */
1107
1108   dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM);
1109   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
1110                        CANNOT_WRITE_PC);
1111   write_memory_unsigned_integer (to + 8, 4, byte_order, from);
1112
1113   dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
1114 }
1115
1116 /* Linux-specific displaced step instruction copying function.  Detects when
1117    the program has stepped into a Linux kernel helper routine (which must be
1118    handled as a special case), falling back to arm_displaced_step_copy_insn()
1119    if it hasn't.  */
1120
1121 static struct displaced_step_closure *
1122 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
1123                                     CORE_ADDR from, CORE_ADDR to,
1124                                     struct regcache *regs)
1125 {
1126   struct displaced_step_closure *dsc = XNEW (struct displaced_step_closure);
1127
1128   /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1129      stop at the return location.  */
1130   if (from > 0xffff0000)
1131     {
1132       if (debug_displaced)
1133         fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
1134                             "at %.8lx\n", (unsigned long) from);
1135
1136       arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
1137     }
1138   else
1139     {
1140       /* Override the default handling of SVC instructions.  */
1141       dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
1142
1143       arm_process_displaced_insn (gdbarch, from, to, regs, dsc);
1144     }
1145
1146   arm_displaced_init_closure (gdbarch, from, to, dsc);
1147
1148   return dsc;
1149 }
1150
1151 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1152    gdbarch.h.  */
1153
1154 static int
1155 arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
1156 {
1157   return (*s == '#' || *s == '$' || isdigit (*s) /* Literal number.  */
1158           || *s == '[' /* Register indirection or
1159                           displacement.  */
1160           || isalpha (*s)); /* Register value.  */
1161 }
1162
1163 /* This routine is used to parse a special token in ARM's assembly.
1164
1165    The special tokens parsed by it are:
1166
1167       - Register displacement (e.g, [fp, #-8])
1168
1169    It returns one if the special token has been parsed successfully,
1170    or zero if the current token is not considered special.  */
1171
1172 static int
1173 arm_stap_parse_special_token (struct gdbarch *gdbarch,
1174                               struct stap_parse_info *p)
1175 {
1176   if (*p->arg == '[')
1177     {
1178       /* Temporary holder for lookahead.  */
1179       const char *tmp = p->arg;
1180       char *endp;
1181       /* Used to save the register name.  */
1182       const char *start;
1183       char *regname;
1184       int len, offset;
1185       int got_minus = 0;
1186       long displacement;
1187       struct stoken str;
1188
1189       ++tmp;
1190       start = tmp;
1191
1192       /* Register name.  */
1193       while (isalnum (*tmp))
1194         ++tmp;
1195
1196       if (*tmp != ',')
1197         return 0;
1198
1199       len = tmp - start;
1200       regname = (char *) alloca (len + 2);
1201
1202       offset = 0;
1203       if (isdigit (*start))
1204         {
1205           /* If we are dealing with a register whose name begins with a
1206              digit, it means we should prefix the name with the letter
1207              `r', because GDB expects this name pattern.  Otherwise (e.g.,
1208              we are dealing with the register `fp'), we don't need to
1209              add such a prefix.  */
1210           regname[0] = 'r';
1211           offset = 1;
1212         }
1213
1214       strncpy (regname + offset, start, len);
1215       len += offset;
1216       regname[len] = '\0';
1217
1218       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
1219         error (_("Invalid register name `%s' on expression `%s'."),
1220                regname, p->saved_arg);
1221
1222       ++tmp;
1223       tmp = skip_spaces_const (tmp);
1224       if (*tmp == '#' || *tmp == '$')
1225         ++tmp;
1226
1227       if (*tmp == '-')
1228         {
1229           ++tmp;
1230           got_minus = 1;
1231         }
1232
1233       displacement = strtol (tmp, &endp, 10);
1234       tmp = endp;
1235
1236       /* Skipping last `]'.  */
1237       if (*tmp++ != ']')
1238         return 0;
1239
1240       /* The displacement.  */
1241       write_exp_elt_opcode (&p->pstate, OP_LONG);
1242       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
1243       write_exp_elt_longcst (&p->pstate, displacement);
1244       write_exp_elt_opcode (&p->pstate, OP_LONG);
1245       if (got_minus)
1246         write_exp_elt_opcode (&p->pstate, UNOP_NEG);
1247
1248       /* The register name.  */
1249       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1250       str.ptr = regname;
1251       str.length = len;
1252       write_exp_string (&p->pstate, str);
1253       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1254
1255       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
1256
1257       /* Casting to the expected type.  */
1258       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1259       write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
1260       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1261
1262       write_exp_elt_opcode (&p->pstate, UNOP_IND);
1263
1264       p->arg = tmp;
1265     }
1266   else
1267     return 0;
1268
1269   return 1;
1270 }
1271
1272 /* ARM process record-replay constructs: syscall, signal etc.  */
1273
1274 struct linux_record_tdep arm_linux_record_tdep;
1275
1276 /* arm_canonicalize_syscall maps from the native arm Linux set
1277    of syscall ids into a canonical set of syscall ids used by
1278    process record.  */
1279
1280 static enum gdb_syscall
1281 arm_canonicalize_syscall (int syscall)
1282 {
1283   enum { sys_process_vm_writev = 377 };
1284
1285   if (syscall <= gdb_sys_sched_getaffinity)
1286     return (enum gdb_syscall) syscall;
1287   else if (syscall >= 243 && syscall <= 247)
1288     return (enum gdb_syscall) (syscall + 2);
1289   else if (syscall >= 248 && syscall <= 253)
1290     return (enum gdb_syscall) (syscall + 4);
1291
1292   return gdb_sys_no_syscall;
1293 }
1294
1295 /* Record all registers but PC register for process-record.  */
1296
1297 static int
1298 arm_all_but_pc_registers_record (struct regcache *regcache)
1299 {
1300   int i;
1301
1302   for (i = 0; i < ARM_PC_REGNUM; i++)
1303     {
1304       if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i))
1305         return -1;
1306     }
1307
1308   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1309     return -1;
1310
1311   return 0;
1312 }
1313
1314 /* Handler for arm system call instruction recording.  */
1315
1316 static int
1317 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number)
1318 {
1319   int ret = 0;
1320   enum gdb_syscall syscall_gdb;
1321
1322   syscall_gdb = arm_canonicalize_syscall (svc_number);
1323
1324   if (syscall_gdb == gdb_sys_no_syscall)
1325     {
1326       printf_unfiltered (_("Process record and replay target doesn't "
1327                            "support syscall number %s\n"),
1328                            plongest (svc_number));
1329       return -1;
1330     }
1331
1332   if (syscall_gdb == gdb_sys_sigreturn
1333       || syscall_gdb == gdb_sys_rt_sigreturn)
1334    {
1335      if (arm_all_but_pc_registers_record (regcache))
1336        return -1;
1337      return 0;
1338    }
1339
1340   ret = record_linux_system_call (syscall_gdb, regcache,
1341                                   &arm_linux_record_tdep);
1342   if (ret != 0)
1343     return ret;
1344
1345   /* Record the return value of the system call.  */
1346   if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM))
1347     return -1;
1348   /* Record LR.  */
1349   if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM))
1350     return -1;
1351   /* Record CPSR.  */
1352   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1353     return -1;
1354
1355   return 0;
1356 }
1357
1358 /* Implement the skip_trampoline_code gdbarch method.  */
1359
1360 static CORE_ADDR
1361 arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1362 {
1363   CORE_ADDR target_pc = arm_skip_stub (frame, pc);
1364
1365   if (target_pc != 0)
1366     return target_pc;
1367
1368   return find_solib_trampoline_target (frame, pc);
1369 }
1370
1371 static void
1372 arm_linux_init_abi (struct gdbarch_info info,
1373                     struct gdbarch *gdbarch)
1374 {
1375   static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL };
1376   static const char *const stap_register_prefixes[] = { "r", NULL };
1377   static const char *const stap_register_indirection_prefixes[] = { "[",
1378                                                                     NULL };
1379   static const char *const stap_register_indirection_suffixes[] = { "]",
1380                                                                     NULL };
1381   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1382
1383   linux_init_abi (info, gdbarch);
1384
1385   tdep->lowest_pc = 0x8000;
1386   if (info.byte_order_for_code == BFD_ENDIAN_BIG)
1387     {
1388       if (tdep->arm_abi == ARM_ABI_AAPCS)
1389         tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
1390       else
1391         tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
1392       tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
1393       tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
1394     }
1395   else
1396     {
1397       if (tdep->arm_abi == ARM_ABI_AAPCS)
1398         tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
1399       else
1400         tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
1401       tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
1402       tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
1403     }
1404   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
1405   tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
1406   tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);
1407
1408   if (tdep->fp_model == ARM_FLOAT_AUTO)
1409     tdep->fp_model = ARM_FLOAT_FPA;
1410
1411   switch (tdep->fp_model)
1412     {
1413     case ARM_FLOAT_FPA:
1414       tdep->jb_pc = ARM_LINUX_JB_PC_FPA;
1415       break;
1416     case ARM_FLOAT_SOFT_FPA:
1417     case ARM_FLOAT_SOFT_VFP:
1418     case ARM_FLOAT_VFP:
1419       tdep->jb_pc = ARM_LINUX_JB_PC_EABI;
1420       break;
1421     default:
1422       internal_error
1423         (__FILE__, __LINE__,
1424          _("arm_linux_init_abi: Floating point model not supported"));
1425       break;
1426     }
1427   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
1428
1429   set_solib_svr4_fetch_link_map_offsets
1430     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
1431
1432   /* Single stepping.  */
1433   set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
1434
1435   /* Shared library handling.  */
1436   set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code);
1437   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1438
1439   /* Enable TLS support.  */
1440   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1441                                              svr4_fetch_objfile_link_map);
1442
1443   tramp_frame_prepend_unwinder (gdbarch,
1444                                 &arm_linux_sigreturn_tramp_frame);
1445   tramp_frame_prepend_unwinder (gdbarch,
1446                                 &arm_linux_rt_sigreturn_tramp_frame);
1447   tramp_frame_prepend_unwinder (gdbarch,
1448                                 &arm_eabi_linux_sigreturn_tramp_frame);
1449   tramp_frame_prepend_unwinder (gdbarch,
1450                                 &arm_eabi_linux_rt_sigreturn_tramp_frame);
1451   tramp_frame_prepend_unwinder (gdbarch,
1452                                 &thumb2_eabi_linux_sigreturn_tramp_frame);
1453   tramp_frame_prepend_unwinder (gdbarch,
1454                                 &thumb2_eabi_linux_rt_sigreturn_tramp_frame);
1455   tramp_frame_prepend_unwinder (gdbarch,
1456                                 &arm_linux_restart_syscall_tramp_frame);
1457   tramp_frame_prepend_unwinder (gdbarch,
1458                                 &arm_kernel_linux_restart_syscall_tramp_frame);
1459
1460   /* Core file support.  */
1461   set_gdbarch_iterate_over_regset_sections
1462     (gdbarch, arm_linux_iterate_over_regset_sections);
1463   set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description);
1464
1465   /* Displaced stepping.  */
1466   set_gdbarch_displaced_step_copy_insn (gdbarch,
1467                                         arm_linux_displaced_step_copy_insn);
1468   set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
1469   set_gdbarch_displaced_step_free_closure (gdbarch,
1470                                            simple_displaced_step_free_closure);
1471   set_gdbarch_displaced_step_location (gdbarch, linux_displaced_step_location);
1472
1473   /* Reversible debugging, process record.  */
1474   set_gdbarch_process_record (gdbarch, arm_process_record);
1475
1476   /* SystemTap functions.  */
1477   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1478   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1479   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
1480                                           stap_register_indirection_prefixes);
1481   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
1482                                           stap_register_indirection_suffixes);
1483   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
1484   set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand);
1485   set_gdbarch_stap_parse_special_token (gdbarch,
1486                                         arm_stap_parse_special_token);
1487
1488   tdep->syscall_next_pc = arm_linux_syscall_next_pc;
1489
1490   /* `catch syscall' */
1491   set_xml_syscall_file_name (gdbarch, "syscalls/arm-linux.xml");
1492   set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number);
1493
1494   /* Syscall record.  */
1495   tdep->arm_syscall_record = arm_linux_syscall_record;
1496
1497   /* Initialize the arm_linux_record_tdep.  */
1498   /* These values are the size of the type that will be used in a system
1499      call.  They are obtained from Linux Kernel source.  */
1500   arm_linux_record_tdep.size_pointer
1501     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1502   arm_linux_record_tdep.size__old_kernel_stat = 32;
1503   arm_linux_record_tdep.size_tms = 16;
1504   arm_linux_record_tdep.size_loff_t = 8;
1505   arm_linux_record_tdep.size_flock = 16;
1506   arm_linux_record_tdep.size_oldold_utsname = 45;
1507   arm_linux_record_tdep.size_ustat = 20;
1508   arm_linux_record_tdep.size_old_sigaction = 16;
1509   arm_linux_record_tdep.size_old_sigset_t = 4;
1510   arm_linux_record_tdep.size_rlimit = 8;
1511   arm_linux_record_tdep.size_rusage = 72;
1512   arm_linux_record_tdep.size_timeval = 8;
1513   arm_linux_record_tdep.size_timezone = 8;
1514   arm_linux_record_tdep.size_old_gid_t = 2;
1515   arm_linux_record_tdep.size_old_uid_t = 2;
1516   arm_linux_record_tdep.size_fd_set = 128;
1517   arm_linux_record_tdep.size_old_dirent = 268;
1518   arm_linux_record_tdep.size_statfs = 64;
1519   arm_linux_record_tdep.size_statfs64 = 84;
1520   arm_linux_record_tdep.size_sockaddr = 16;
1521   arm_linux_record_tdep.size_int
1522     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1523   arm_linux_record_tdep.size_long
1524     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1525   arm_linux_record_tdep.size_ulong
1526     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1527   arm_linux_record_tdep.size_msghdr = 28;
1528   arm_linux_record_tdep.size_itimerval = 16;
1529   arm_linux_record_tdep.size_stat = 88;
1530   arm_linux_record_tdep.size_old_utsname = 325;
1531   arm_linux_record_tdep.size_sysinfo = 64;
1532   arm_linux_record_tdep.size_msqid_ds = 88;
1533   arm_linux_record_tdep.size_shmid_ds = 84;
1534   arm_linux_record_tdep.size_new_utsname = 390;
1535   arm_linux_record_tdep.size_timex = 128;
1536   arm_linux_record_tdep.size_mem_dqinfo = 24;
1537   arm_linux_record_tdep.size_if_dqblk = 68;
1538   arm_linux_record_tdep.size_fs_quota_stat = 68;
1539   arm_linux_record_tdep.size_timespec = 8;
1540   arm_linux_record_tdep.size_pollfd = 8;
1541   arm_linux_record_tdep.size_NFS_FHSIZE = 32;
1542   arm_linux_record_tdep.size_knfsd_fh = 132;
1543   arm_linux_record_tdep.size_TASK_COMM_LEN = 16;
1544   arm_linux_record_tdep.size_sigaction = 20;
1545   arm_linux_record_tdep.size_sigset_t = 8;
1546   arm_linux_record_tdep.size_siginfo_t = 128;
1547   arm_linux_record_tdep.size_cap_user_data_t = 12;
1548   arm_linux_record_tdep.size_stack_t = 12;
1549   arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long;
1550   arm_linux_record_tdep.size_stat64 = 96;
1551   arm_linux_record_tdep.size_gid_t = 4;
1552   arm_linux_record_tdep.size_uid_t = 4;
1553   arm_linux_record_tdep.size_PAGE_SIZE = 4096;
1554   arm_linux_record_tdep.size_flock64 = 24;
1555   arm_linux_record_tdep.size_user_desc = 16;
1556   arm_linux_record_tdep.size_io_event = 32;
1557   arm_linux_record_tdep.size_iocb = 64;
1558   arm_linux_record_tdep.size_epoll_event = 12;
1559   arm_linux_record_tdep.size_itimerspec
1560     = arm_linux_record_tdep.size_timespec * 2;
1561   arm_linux_record_tdep.size_mq_attr = 32;
1562   arm_linux_record_tdep.size_termios = 36;
1563   arm_linux_record_tdep.size_termios2 = 44;
1564   arm_linux_record_tdep.size_pid_t = 4;
1565   arm_linux_record_tdep.size_winsize = 8;
1566   arm_linux_record_tdep.size_serial_struct = 60;
1567   arm_linux_record_tdep.size_serial_icounter_struct = 80;
1568   arm_linux_record_tdep.size_hayes_esp_config = 12;
1569   arm_linux_record_tdep.size_size_t = 4;
1570   arm_linux_record_tdep.size_iovec = 8;
1571   arm_linux_record_tdep.size_time_t = 4;
1572
1573   /* These values are the second argument of system call "sys_ioctl".
1574      They are obtained from Linux Kernel source.  */
1575   arm_linux_record_tdep.ioctl_TCGETS = 0x5401;
1576   arm_linux_record_tdep.ioctl_TCSETS = 0x5402;
1577   arm_linux_record_tdep.ioctl_TCSETSW = 0x5403;
1578   arm_linux_record_tdep.ioctl_TCSETSF = 0x5404;
1579   arm_linux_record_tdep.ioctl_TCGETA = 0x5405;
1580   arm_linux_record_tdep.ioctl_TCSETA = 0x5406;
1581   arm_linux_record_tdep.ioctl_TCSETAW = 0x5407;
1582   arm_linux_record_tdep.ioctl_TCSETAF = 0x5408;
1583   arm_linux_record_tdep.ioctl_TCSBRK = 0x5409;
1584   arm_linux_record_tdep.ioctl_TCXONC = 0x540a;
1585   arm_linux_record_tdep.ioctl_TCFLSH = 0x540b;
1586   arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
1587   arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
1588   arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
1589   arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
1590   arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
1591   arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
1592   arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
1593   arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
1594   arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
1595   arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
1596   arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
1597   arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
1598   arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
1599   arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
1600   arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
1601   arm_linux_record_tdep.ioctl_FIONREAD = 0x541b;
1602   arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD;
1603   arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
1604   arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
1605   arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
1606   arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
1607   arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
1608   arm_linux_record_tdep.ioctl_FIONBIO = 0x5421;
1609   arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
1610   arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
1611   arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
1612   arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
1613   arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
1614   arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
1615   arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
1616   arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
1617   arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1618   arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1619   arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
1620   arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1621   arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1622   arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1623   arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1624   arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1625   arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1626   arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1627   arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1628   arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1629   arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1630   arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1631   arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1632   arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1633   arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
1634   arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
1635   arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
1636   arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
1637   arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
1638   arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
1639   arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1640
1641   /* These values are the second argument of system call "sys_fcntl"
1642      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1643   arm_linux_record_tdep.fcntl_F_GETLK = 5;
1644   arm_linux_record_tdep.fcntl_F_GETLK64 = 12;
1645   arm_linux_record_tdep.fcntl_F_SETLK64 = 13;
1646   arm_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1647
1648   arm_linux_record_tdep.arg1 = ARM_A1_REGNUM + 1;
1649   arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 2;
1650   arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 3;
1651   arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3;
1652 }
1653
1654 /* Provide a prototype to silence -Wmissing-prototypes.  */
1655 extern initialize_file_ftype _initialize_arm_linux_tdep;
1656
1657 void
1658 _initialize_arm_linux_tdep (void)
1659 {
1660   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
1661                           arm_linux_init_abi);
1662 }