gdb/arm-linux-tdep.c

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