gdb/arm-linux-tdep.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* GNU/Linux on ARM target support.

  3.    Copyright (C) 1999-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  38. #include "arm-tdep.h"
  39. #include "arm-linux-tdep.h"
  40. #include "linux-tdep.h"
  41. #include "glibc-tdep.h"
  42. #include "arch-utils.h"
  43. #include "inferior.h"
  44. #include "infrun.h"
  45. #include "gdbthread.h"
  46. #include "symfile.h"

  48. #include "record-full.h"
  49. #include "linux-record.h"

  51. #include "cli/cli-utils.h"
  52. #include "stap-probe.h"
  53. #include "parser-defs.h"
  54. #include "user-regs.h"
  55. #include <ctype.h>
  56. #include "elf/common.h"
  57. extern int arm_apcs_32;

  59. /* Under ARM GNU/Linux the traditional way of performing a breakpoint
  60.    is to execute a particular software interrupt, rather than use a
  61.    particular undefined instruction to provoke a trap.  Upon exection
  62.    of the software interrupt the kernel stops the inferior with a
  63.    SIGTRAP, and wakes the debugger.  */

  65. ‌static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };

  67. ‌static const gdb_byte arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };

  69. /* However, the EABI syscall interface (new in Nov. 2005) does not look at
  70.    the operand of the swi if old-ABI compatibility is disabled.  Therefore,
  71.    use an undefined instruction instead.  This is supported as of kernel
  72.    version 2.5.70 (May 2003), so should be a safe assumption for EABI
  73.    binaries.  */

  75. ‌static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };

  77. ‌static const gdb_byte eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };

  79. /* All the kernels which support Thumb support using a specific undefined
  80.    instruction for the Thumb breakpoint.  */

  82. ‌static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};

  84. ‌static const gdb_byte arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};

  86. /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
  87.    we must use a length-appropriate breakpoint for 32-bit Thumb
  88.    instructions.  See also thumb_get_next_pc.  */

  90. ‌static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };

  92. ‌static const gdb_byte arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 };

  94. /* Description of the longjmp buffer.  The buffer is treated as an array of
  95.    elements of size ARM_LINUX_JB_ELEMENT_SIZE.

  97.    The location of saved registers in this buffer (in particular the PC
  98.    to use after longjmp is called) varies depending on the ABI (in
  99.    particular the FP model) and also (possibly) the C Library.

  101.    For glibc, eglibc, and uclibc the following holds:  If the FP model is
  102.    SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
  103.    buffer.  This is also true for the SoftFPA model.  However, for the FPA
  104.    model the PC is at offset 21 in the buffer.  */
  105. ‌#define ARM_LINUX_JB_ELEMENT_SIZE        INT_REGISTER_SIZE
  106. ‌#define ARM_LINUX_JB_PC_FPA                21
  107. ‌#define ARM_LINUX_JB_PC_EABI                9

  109. /*
  110.    Dynamic Linking on ARM GNU/Linux
  111.    --------------------------------

  113.    Note: PLT = procedure linkage table
  114.    GOT = global offset table

  116.    As much as possible, ELF dynamic linking defers the resolution of
  117.    jump/call addresses until the last minute.  The technique used is
  118.    inspired by the i386 ELF design, and is based on the following
  119.    constraints.

  121.    1) The calling technique should not force a change in the assembly
  122.    code produced for apps; it MAY cause changes in the way assembly
  123.    code is produced for position independent code (i.e. shared
  124.    libraries).

  126.    2) The technique must be such that all executable areas must not be
  127.    modified; and any modified areas must not be executed.

  129.    To do this, there are three steps involved in a typical jump:

  131.    1) in the code
  132.    2) through the PLT
  133.    3) using a pointer from the GOT

  135.    When the executable or library is first loaded, each GOT entry is
  136.    initialized to point to the code which implements dynamic name
  137.    resolution and code finding.  This is normally a function in the
  138.    program interpreter (on ARM GNU/Linux this is usually
  139.    ld-linux.so.2, but it does not have to be).  On the first
  140.    invocation, the function is located and the GOT entry is replaced
  141.    with the real function address.  Subsequent calls go through steps
  142.    1, 2 and 3 and end up calling the real code.

  144.    1) In the code:

  146.    b    function_call
  147.    bl   function_call

  149.    This is typical ARM code using the 26 bit relative branch or branch
  150.    and link instructions.  The target of the instruction
  151.    (function_call is usually the address of the function to be called.
  152.    In position independent code, the target of the instruction is
  153.    actually an entry in the PLT when calling functions in a shared
  154.    library.  Note that this call is identical to a normal function
  155.    call, only the target differs.

  157.    2) In the PLT:

  159.    The PLT is a synthetic area, created by the linker.  It exists in
  160.    both executables and libraries.  It is an array of stubs, one per
  161.    imported function call.  It looks like this:

  163.    PLT[0]:
  164.    str     lr, [sp, #-4]!       @push the return address (lr)
  165.    ldr     lr, [pc, #16]   @load from 6 words ahead
  166.    add     lr, pc, lr      @form an address for GOT[0]
  167.    ldr     pc, [lr, #8]!   @jump to the contents of that addr

  169.    The return address (lr) is pushed on the stack and used for
  170.    calculations.  The load on the second line loads the lr with
  171.    &GOT[3] - . - 20.  The addition on the third leaves:

  173.    lr = (&GOT[3] - . - 20) + (. + 8)
  174.    lr = (&GOT[3] - 12)
  175.    lr = &GOT[0]

  177.    On the fourth line, the pc and lr are both updated, so that:

  179.    pc = GOT[2]
  180.    lr = &GOT[0] + 8
  181.    = &GOT[2]

  183.    NOTE: PLT[0] borrows an offset .word from PLT[1].  This is a little
  184.    "tight", but allows us to keep all the PLT entries the same size.

  186.    PLT[n+1]:
  187.    ldr     ip, [pc, #4]    @load offset from gotoff
  188.    add     ip, pc, ip      @add the offset to the pc
  189.    ldr     pc, [ip]        @jump to that address
  190.    gotoff: .word   GOT[n+3] - .

  192.    The load on the first line, gets an offset from the fourth word of
  193.    the PLT entry.  The add on the second line makes ip = &GOT[n+3],
  194.    which contains either a pointer to PLT[0] (the fixup trampoline) or
  195.    a pointer to the actual code.

  197.    3) In the GOT:

  199.    The GOT contains helper pointers for both code (PLT) fixups and
  200.    data fixups.  The first 3 entries of the GOT are special.  The next
  201.    M entries (where M is the number of entries in the PLT) belong to
  202.    the PLT fixups.  The next D (all remaining) entries belong to
  203.    various data fixups.  The actual size of the GOT is 3 + M + D.

  205.    The GOT is also a synthetic area, created by the linker.  It exists
  206.    in both executables and libraries.  When the GOT is first
  207.    initialized , all the GOT entries relating to PLT fixups are
  208.    pointing to code back at PLT[0].

  210.    The special entries in the GOT are:

  212.    GOT[0] = linked list pointer used by the dynamic loader
  213.    GOT[1] = pointer to the reloc table for this module
  214.    GOT[2] = pointer to the fixup/resolver code

  216.    The first invocation of function call comes through and uses the
  217.    fixup/resolver code.  On the entry to the fixup/resolver code:

  219.    ip = &GOT[n+3]
  220.    lr = &GOT[2]
  221.    stack[0] = return address (lr) of the function call
  222.    [r0, r1, r2, r3] are still the arguments to the function call

  224.    This is enough information for the fixup/resolver code to work
  225.    with.  Before the fixup/resolver code returns, it actually calls
  226.    the requested function and repairs &GOT[n+3].  */

  228. /* The constants below were determined by examining the following files
  229.    in the linux kernel sources:

  231.       arch/arm/kernel/signal.c
  232.           - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
  233.       include/asm-arm/unistd.h
  234.           - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */

  236. ‌#define ARM_LINUX_SIGRETURN_INSTR        0xef900077
  237. ‌#define ARM_LINUX_RT_SIGRETURN_INSTR        0xef9000ad

  239. /* For ARM EABI, the syscall number is not in the SWI instruction
  240.    (instead it is loaded into r7).  We recognize the pattern that
  241.    glibc uses...  alternatively, we could arrange to do this by
  242.    function name, but they are not always exported.  */
  243. ‌#define ARM_SET_R7_SIGRETURN                0xe3a07077
  244. ‌#define ARM_SET_R7_RT_SIGRETURN                0xe3a070ad
  245. ‌#define ARM_EABI_SYSCALL                0xef000000

  247. /* Equivalent patterns for Thumb2.  */
  248. ‌#define THUMB2_SET_R7_SIGRETURN1        0xf04f
  249. ‌#define THUMB2_SET_R7_SIGRETURN2        0x0777
  250. ‌#define THUMB2_SET_R7_RT_SIGRETURN1        0xf04f
  251. ‌#define THUMB2_SET_R7_RT_SIGRETURN2        0x07ad
  252. ‌#define THUMB2_EABI_SYSCALL                0xdf00

  254. /* OABI syscall restart trampoline, used for EABI executables too
  255.    whenever OABI support has been enabled in the kernel.  */
  256. ‌#define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
  257. ‌#define ARM_LDR_PC_SP_12                0xe49df00c
  258. ‌#define ARM_LDR_PC_SP_4                        0xe49df004

  260. static void
  261. ‌arm_linux_sigtramp_cache (struct frame_info *this_frame,
  262.                           struct trad_frame_cache *this_cache,
  263.                           CORE_ADDR func, int regs_offset)
  264. {
  265.   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  266.   CORE_ADDR base = sp + regs_offset;
  267.   int i;

  269.   for (i = 0; i < 16; i++)
  270.     trad_frame_set_reg_addr (this_cache, i, base + i * 4);

  272.   trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);

  274.   /* The VFP or iWMMXt registers may be saved on the stack, but there's
  275.      no reliable way to restore them (yet).  */

  277.   /* Save a frame ID.  */
  278.   trad_frame_set_id (this_cache, frame_id_build (sp, func));
  279. }

  281. /* There are a couple of different possible stack layouts that
  282.    we need to support.

  284.    Before version 2.6.18, the kernel used completely independent
  285.    layouts for non-RT and RT signals.  For non-RT signals the stack
  286.    began directly with a struct sigcontext.  For RT signals the stack
  287.    began with two redundant pointers (to the siginfo and ucontext),
  288.    and then the siginfo and ucontext.

  290.    As of version 2.6.18, the non-RT signal frame layout starts with
  291.    a ucontext and the RT signal frame starts with a siginfo and then
  292.    a ucontext.  Also, the ucontext now has a designated save area
  293.    for coprocessor registers.

  295.    For RT signals, it's easy to tell the difference: we look for
  296.    pinfo, the pointer to the siginfo.  If it has the expected
  297.    value, we have an old layout.  If it doesn't, we have the new
  298.    layout.

  300.    For non-RT signals, it's a bit harder.  We need something in one
  301.    layout or the other with a recognizable offset and value.  We can't
  302.    use the return trampoline, because ARM usually uses SA_RESTORER,
  303.    in which case the stack return trampoline is not filled in.
  304.    We can't use the saved stack pointer, because sigaltstack might
  305.    be in use.  So for now we guess the new layout...  */

  307. /* There are three words (trap_no, error_code, oldmask) in
  308.    struct sigcontext before r0.  */
  309. ‌#define ARM_SIGCONTEXT_R0 0xc

  311. /* There are five words (uc_flags, uc_link, and three for uc_stack)
  312.    in the ucontext_t before the sigcontext.  */
  313. ‌#define ARM_UCONTEXT_SIGCONTEXT 0x14

  315. /* There are three elements in an rt_sigframe before the ucontext:
  316.    pinfo, puc, and info.  The first two are pointers and the third
  317.    is a struct siginfo, with size 128 bytes.  We could follow puc
  318.    to the ucontext, but it's simpler to skip the whole thing.  */
  319. ‌#define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
  320. ‌#define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88

  322. ‌#define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80

  324. ‌#define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a

  326. static void
  327. ‌arm_linux_sigreturn_init (const struct tramp_frame *self,
  328.                           struct frame_info *this_frame,
  329.                           struct trad_frame_cache *this_cache,
  330.                           CORE_ADDR func)
  331. {
  332.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  333.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  334.   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  335.   ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);

  337.   if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
  338.     arm_linux_sigtramp_cache (this_frame, this_cache, func,
  339.                               ARM_UCONTEXT_SIGCONTEXT
  340.                               + ARM_SIGCONTEXT_R0);
  341.   else
  342.     arm_linux_sigtramp_cache (this_frame, this_cache, func,
  343.                               ARM_SIGCONTEXT_R0);
  344. }

  346. static void
  347. ‌arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
  348.                           struct frame_info *this_frame,
  349.                           struct trad_frame_cache *this_cache,
  350.                           CORE_ADDR func)
  351. {
  352.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  353.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  354.   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  355.   ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);

  357.   if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
  358.     arm_linux_sigtramp_cache (this_frame, this_cache, func,
  359.                               ARM_OLD_RT_SIGFRAME_UCONTEXT
  360.                               + ARM_UCONTEXT_SIGCONTEXT
  361.                               + ARM_SIGCONTEXT_R0);
  362.   else
  363.     arm_linux_sigtramp_cache (this_frame, this_cache, func,
  364.                               ARM_NEW_RT_SIGFRAME_UCONTEXT
  365.                               + ARM_UCONTEXT_SIGCONTEXT
  366.                               + ARM_SIGCONTEXT_R0);
  367. }

  369. static void
  370. ‌arm_linux_restart_syscall_init (const struct tramp_frame *self,
  371.                                 struct frame_info *this_frame,
  372.                                 struct trad_frame_cache *this_cache,
  373.                                 CORE_ADDR func)
  374. {
  375.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  376.   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  377.   CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4);
  378.   CORE_ADDR cpsr = get_frame_register_unsigned (this_frame, ARM_PS_REGNUM);
  379.   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
  380.   int sp_offset;

  382.   /* There are two variants of this trampoline; with older kernels, the
  383.      stub is placed on the stack, while newer kernels use the stub from
  384.      the vector page.  They are identical except that the older version
  385.      increments SP by 12 (to skip stored PC and the stub itself), while
  386.      the newer version increments SP only by 4 (just the stored PC).  */
  387.   if (self->insn[1].bytes == ARM_LDR_PC_SP_4)
  388.     sp_offset = 4;
  389.   else
  390.     sp_offset = 12;

  392.   /* Update Thumb bit in CPSR.  */
  393.   if (pc & 1)
  394.     cpsr |= t_bit;
  395.   else
  396.     cpsr &= ~t_bit;

  398.   /* Remove Thumb bit from PC.  */
  399.   pc = gdbarch_addr_bits_remove (gdbarch, pc);

  401.   /* Save previous register values.  */
  402.   trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset);
  403.   trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc);
  404.   trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr);

  406.   /* Save a frame ID.  */
  407.   trad_frame_set_id (this_cache, frame_id_build (sp, func));
  408. }

  410. ‌static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
  411.   SIGTRAMP_FRAME,
  412.   4,
  413.   {
  414.     { ARM_LINUX_SIGRETURN_INSTR, -1 },
  415.     { TRAMP_SENTINEL_INSN }
  416.   },
  417.   arm_linux_sigreturn_init
  418. };

  420. ‌static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
  421.   SIGTRAMP_FRAME,
  422.   4,
  423.   {
  424.     { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
  425.     { TRAMP_SENTINEL_INSN }
  426.   },
  427.   arm_linux_rt_sigreturn_init
  428. };

  430. ‌static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
  431.   SIGTRAMP_FRAME,
  432.   4,
  433.   {
  434.     { ARM_SET_R7_SIGRETURN, -1 },
  435.     { ARM_EABI_SYSCALL, -1 },
  436.     { TRAMP_SENTINEL_INSN }
  437.   },
  438.   arm_linux_sigreturn_init
  439. };

  441. ‌static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
  442.   SIGTRAMP_FRAME,
  443.   4,
  444.   {
  445.     { ARM_SET_R7_RT_SIGRETURN, -1 },
  446.     { ARM_EABI_SYSCALL, -1 },
  447.     { TRAMP_SENTINEL_INSN }
  448.   },
  449.   arm_linux_rt_sigreturn_init
  450. };

  452. ‌static struct tramp_frame thumb2_eabi_linux_sigreturn_tramp_frame = {
  453.   SIGTRAMP_FRAME,
  454.   2,
  455.   {
  456.     { THUMB2_SET_R7_SIGRETURN1, -1 },
  457.     { THUMB2_SET_R7_SIGRETURN2, -1 },
  458.     { THUMB2_EABI_SYSCALL, -1 },
  459.     { TRAMP_SENTINEL_INSN }
  460.   },
  461.   arm_linux_sigreturn_init
  462. };

  464. ‌static struct tramp_frame thumb2_eabi_linux_rt_sigreturn_tramp_frame = {
  465.   SIGTRAMP_FRAME,
  466.   2,
  467.   {
  468.     { THUMB2_SET_R7_RT_SIGRETURN1, -1 },
  469.     { THUMB2_SET_R7_RT_SIGRETURN2, -1 },
  470.     { THUMB2_EABI_SYSCALL, -1 },
  471.     { TRAMP_SENTINEL_INSN }
  472.   },
  473.   arm_linux_rt_sigreturn_init
  474. };

  476. ‌static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
  477.   NORMAL_FRAME,
  478.   4,
  479.   {
  480.     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
  481.     { ARM_LDR_PC_SP_12, -1 },
  482.     { TRAMP_SENTINEL_INSN }
  483.   },
  484.   arm_linux_restart_syscall_init
  485. };

  487. ‌static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
  488.   NORMAL_FRAME,
  489.   4,
  490.   {
  491.     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
  492.     { ARM_LDR_PC_SP_4, -1 },
  493.     { TRAMP_SENTINEL_INSN }
  494.   },
  495.   arm_linux_restart_syscall_init
  496. };

  498. /* Core file and register set support.  */

  500. ‌#define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)

  502. void
  503. ‌arm_linux_supply_gregset (const struct regset *regset,
  504.                           struct regcache *regcache,
  505.                           int regnum, const void *gregs_buf, size_t len)
  506. {
  507.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  508.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  509.   const gdb_byte *gregs = gregs_buf;
  510.   int regno;
  511.   CORE_ADDR reg_pc;
  512.   gdb_byte pc_buf[INT_REGISTER_SIZE];

  514.   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
  515.     if (regnum == -1 || regnum == regno)
  516.       regcache_raw_supply (regcache, regno,
  517.                            gregs + INT_REGISTER_SIZE * regno);

  519.   if (regnum == ARM_PS_REGNUM || regnum == -1)
  520.     {
  521.       if (arm_apcs_32)
  522.         regcache_raw_supply (regcache, ARM_PS_REGNUM,
  523.                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
  524.       else
  525.         regcache_raw_supply (regcache, ARM_PS_REGNUM,
  526.                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
  527.     }

  529.   if (regnum == ARM_PC_REGNUM || regnum == -1)
  530.     {
  531.       reg_pc = extract_unsigned_integer (gregs
  532.                                          + INT_REGISTER_SIZE * ARM_PC_REGNUM,
  533.                                          INT_REGISTER_SIZE, byte_order);
  534.       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
  535.       store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
  536.       regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
  537.     }
  538. }

  540. void
  541. ‌arm_linux_collect_gregset (const struct regset *regset,
  542.                            const struct regcache *regcache,
  543.                            int regnum, void *gregs_buf, size_t len)
  544. {
  545.   gdb_byte *gregs = gregs_buf;
  546.   int regno;

  548.   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
  549.     if (regnum == -1 || regnum == regno)
  550.       regcache_raw_collect (regcache, regno,
  551.                             gregs + INT_REGISTER_SIZE * regno);

  553.   if (regnum == ARM_PS_REGNUM || regnum == -1)
  554.     {
  555.       if (arm_apcs_32)
  556.         regcache_raw_collect (regcache, ARM_PS_REGNUM,
  557.                               gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
  558.       else
  559.         regcache_raw_collect (regcache, ARM_PS_REGNUM,
  560.                               gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
  561.     }

  563.   if (regnum == ARM_PC_REGNUM || regnum == -1)
  564.     regcache_raw_collect (regcache, ARM_PC_REGNUM,
  565.                           gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
  566. }

  568. /* Support for register format used by the NWFPE FPA emulator.  */

  570. ‌#define typeNone                0x00
  571. ‌#define typeSingle                0x01
  572. ‌#define typeDouble                0x02
  573. ‌#define typeExtended                0x03

  575. void
  576. ‌supply_nwfpe_register (struct regcache *regcache, int regno,
  577.                        const gdb_byte *regs)
  578. {
  579.   const gdb_byte *reg_data;
  580.   gdb_byte reg_tag;
  581.   gdb_byte buf[FP_REGISTER_SIZE];

  583.   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
  584.   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
  585.   memset (buf, 0, FP_REGISTER_SIZE);

  587.   switch (reg_tag)
  588.     {
  589.     case typeSingle:
  590.       memcpy (buf, reg_data, 4);
  591.       break;
  592.     case typeDouble:
  593.       memcpy (buf, reg_data + 4, 4);
  594.       memcpy (buf + 4, reg_data, 4);
  595.       break;
  596.     case typeExtended:
  597.       /* We want sign and exponent, then least significant bits,
  598.          then most significant.  NWFPE does sign, most, least.  */
  599.       memcpy (buf, reg_data, 4);
  600.       memcpy (buf + 4, reg_data + 8, 4);
  601.       memcpy (buf + 8, reg_data + 4, 4);
  602.       break;
  603.     default:
  604.       break;
  605.     }

  607.   regcache_raw_supply (regcache, regno, buf);
  608. }

  610. void
  611. ‌collect_nwfpe_register (const struct regcache *regcache, int regno,
  612.                         gdb_byte *regs)
  613. {
  614.   gdb_byte *reg_data;
  615.   gdb_byte reg_tag;
  616.   gdb_byte buf[FP_REGISTER_SIZE];

  618.   regcache_raw_collect (regcache, regno, buf);

  620.   /* NOTE drow/2006-06-07: This code uses the tag already in the
  621.      register buffer.  I've preserved that when moving the code
  622.      from the native file to the target file.  But this doesn't
  623.      always make sense.  */

  625.   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
  626.   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];

  628.   switch (reg_tag)
  629.     {
  630.     case typeSingle:
  631.       memcpy (reg_data, buf, 4);
  632.       break;
  633.     case typeDouble:
  634.       memcpy (reg_data, buf + 4, 4);
  635.       memcpy (reg_data + 4, buf, 4);
  636.       break;
  637.     case typeExtended:
  638.       memcpy (reg_data, buf, 4);
  639.       memcpy (reg_data + 4, buf + 8, 4);
  640.       memcpy (reg_data + 8, buf + 4, 4);
  641.       break;
  642.     default:
  643.       break;
  644.     }
  645. }

  647. void
  648. ‌arm_linux_supply_nwfpe (const struct regset *regset,
  649.                         struct regcache *regcache,
  650.                         int regnum, const void *regs_buf, size_t len)
  651. {
  652.   const gdb_byte *regs = regs_buf;
  653.   int regno;

  655.   if (regnum == ARM_FPS_REGNUM || regnum == -1)
  656.     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
  657.                          regs + NWFPE_FPSR_OFFSET);

  659.   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
  660.     if (regnum == -1 || regnum == regno)
  661.       supply_nwfpe_register (regcache, regno, regs);
  662. }

  664. void
  665. ‌arm_linux_collect_nwfpe (const struct regset *regset,
  666.                          const struct regcache *regcache,
  667.                          int regnum, void *regs_buf, size_t len)
  668. {
  669.   gdb_byte *regs = regs_buf;
  670.   int regno;

  672.   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
  673.     if (regnum == -1 || regnum == regno)
  674.       collect_nwfpe_register (regcache, regno, regs);

  676.   if (regnum == ARM_FPS_REGNUM || regnum == -1)
  677.     regcache_raw_collect (regcache, ARM_FPS_REGNUM,
  678.                           regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
  679. }

  681. /* Support VFP register format.  */

  683. ‌#define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)

  685. static void
  686. ‌arm_linux_supply_vfp (const struct regset *regset,
  687.                       struct regcache *regcache,
  688.                       int regnum, const void *regs_buf, size_t len)
  689. {
  690.   const gdb_byte *regs = regs_buf;
  691.   int regno;

  693.   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
  694.     regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);

  696.   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
  697.     if (regnum == -1 || regnum == regno)
  698.       regcache_raw_supply (regcache, regno,
  699.                            regs + (regno - ARM_D0_REGNUM) * 8);
  700. }

  702. static void
  703. ‌arm_linux_collect_vfp (const struct regset *regset,
  704.                          const struct regcache *regcache,
  705.                          int regnum, void *regs_buf, size_t len)
  706. {
  707.   gdb_byte *regs = regs_buf;
  708.   int regno;

  710.   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
  711.     regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);

  713.   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
  714.     if (regnum == -1 || regnum == regno)
  715.       regcache_raw_collect (regcache, regno,
  716.                             regs + (regno - ARM_D0_REGNUM) * 8);
  717. }

  719. ‌static const struct regset arm_linux_gregset =
  720.   {
  721.     NULL, arm_linux_supply_gregset, arm_linux_collect_gregset
  722.   };

  724. ‌static const struct regset arm_linux_fpregset =
  725.   {
  726.     NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe
  727.   };

  729. ‌static const struct regset arm_linux_vfpregset =
  730.   {
  731.     NULL, arm_linux_supply_vfp, arm_linux_collect_vfp
  732.   };

  734. /* Iterate over core file register note sections.  */

  736. static void
  737. ‌arm_linux_iterate_over_regset_sections (struct gdbarch *gdbarch,
  738.                                         iterate_over_regset_sections_cb *cb,
  739.                                         void *cb_data,
  740.                                         const struct regcache *regcache)
  741. {
  742.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  744.   cb (".reg", ARM_LINUX_SIZEOF_GREGSET, &arm_linux_gregset, NULL, cb_data);

  746.   if (tdep->have_vfp_registers)
  747.     cb (".reg-arm-vfp", ARM_LINUX_SIZEOF_VFP, &arm_linux_vfpregset,
  748.         "VFP floating-point", cb_data);
  749.   else if (tdep->have_fpa_registers)
  750.     cb (".reg2", ARM_LINUX_SIZEOF_NWFPE, &arm_linux_fpregset,
  751.         "FPA floating-point", cb_data);
  752. }

  754. /* Determine target description from core file.  */

  756. static const struct target_desc *
  757. ‌arm_linux_core_read_description (struct gdbarch *gdbarch,
  758.                                  struct target_ops *target,
  759.                                  bfd *abfd)
  760. {
  761.   CORE_ADDR arm_hwcap = 0;

  763.   if (target_auxv_search (target, AT_HWCAP, &arm_hwcap) != 1)
  764.     return NULL;

  766.   if (arm_hwcap & HWCAP_VFP)
  767.     {
  768.       /* NEON implies VFPv3-D32 or no-VFP unit.  Say that we only support
  769.          Neon with VFPv3-D32.  */
  770.       if (arm_hwcap & HWCAP_NEON)
  771.         return tdesc_arm_with_neon;
  772.       else if ((arm_hwcap & (HWCAP_VFPv3 | HWCAP_VFPv3D16)) == HWCAP_VFPv3)
  773.         return tdesc_arm_with_vfpv3;
  774.       else
  775.         return tdesc_arm_with_vfpv2;
  776.     }

  778.   return NULL;
  779. }


  782. /* Copy the value of next pc of sigreturn and rt_sigrturn into PC,
  783.    return 1.  In addition, set IS_THUMB depending on whether we
  784.    will return to ARM or Thumb code.  Return 0 if it is not a
  785.    rt_sigreturn/sigreturn syscall.  */
  786. static int
  787. ‌arm_linux_sigreturn_return_addr (struct frame_info *frame,
  788.                                  unsigned long svc_number,
  789.                                  CORE_ADDR *pc, int *is_thumb)
  790. {
  791.   /* Is this a sigreturn or rt_sigreturn syscall?  */
  792.   if (svc_number == 119 || svc_number == 173)
  793.     {
  794.       if (get_frame_type (frame) == SIGTRAMP_FRAME)
  795.         {
  796.           ULONGEST t_bit = arm_psr_thumb_bit (frame_unwind_arch (frame));
  797.           CORE_ADDR cpsr
  798.             = frame_unwind_register_unsigned (frame, ARM_PS_REGNUM);

  800.           *is_thumb = (cpsr & t_bit) != 0;
  801.           *pc = frame_unwind_caller_pc (frame);
  802.           return 1;
  803.         }
  804.     }
  805.   return 0;
  806. }

  808. /* At a ptrace syscall-stop, return the syscall number.  This either
  809.    comes from the SWI instruction (OABI) or from r7 (EABI).

  811.    When the function fails, it should return -1.  */

  813. static LONGEST
  814. ‌arm_linux_get_syscall_number (struct gdbarch *gdbarch,
  815.                               ptid_t ptid)
  816. {
  817.   struct regcache *regs = get_thread_regcache (ptid);
  818.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  820.   ULONGEST pc;
  821.   ULONGEST cpsr;
  822.   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
  823.   int is_thumb;
  824.   ULONGEST svc_number = -1;

  826.   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc);
  827.   regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr);
  828.   is_thumb = (cpsr & t_bit) != 0;

  830.   if (is_thumb)
  831.     {
  832.       regcache_cooked_read_unsigned (regs, 7, &svc_number);
  833.     }
  834.   else
  835.     {
  836.       enum bfd_endian byte_order_for_code =
  837.         gdbarch_byte_order_for_code (gdbarch);

  839.       /* PC gets incremented before the syscall-stop, so read the
  840.          previous instruction.  */
  841.       unsigned long this_instr =
  842.         read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);

  844.       unsigned long svc_operand = (0x00ffffff & this_instr);

  846.       if (svc_operand)
  847.         {
  848.           /* OABI */
  849.           svc_number = svc_operand - 0x900000;
  850.         }
  851.       else
  852.         {
  853.           /* EABI */
  854.           regcache_cooked_read_unsigned (regs, 7, &svc_number);
  855.         }
  856.     }

  858.   return svc_number;
  859. }

  861. /* When FRAME is at a syscall instruction, return the PC of the next
  862.    instruction to be executed.  */

  864. static CORE_ADDR
  865. ‌arm_linux_syscall_next_pc (struct frame_info *frame)
  866. {
  867.   CORE_ADDR pc = get_frame_pc (frame);
  868.   CORE_ADDR return_addr = 0;
  869.   int is_thumb = arm_frame_is_thumb (frame);
  870.   ULONGEST svc_number = 0;

  872.   if (is_thumb)
  873.     {
  874.       svc_number = get_frame_register_unsigned (frame, 7);
  875.       return_addr = pc + 2;
  876.     }
  877.   else
  878.     {
  879.       struct gdbarch *gdbarch = get_frame_arch (frame);
  880.       enum bfd_endian byte_order_for_code =
  881.         gdbarch_byte_order_for_code (gdbarch);
  882.       unsigned long this_instr =
  883.         read_memory_unsigned_integer (pc, 4, byte_order_for_code);

  885.       unsigned long svc_operand = (0x00ffffff & this_instr);
  886.       if (svc_operand)  /* OABI.  */
  887.         {
  888.           svc_number = svc_operand - 0x900000;
  889.         }
  890.       else /* EABI.  */
  891.         {
  892.           svc_number = get_frame_register_unsigned (frame, 7);
  893.         }

  895.       return_addr = pc + 4;
  896.     }

  898.   arm_linux_sigreturn_return_addr (frame, svc_number, &return_addr, &is_thumb);

  900.   /* Addresses for calling Thumb functions have the bit 0 set.  */
  901.   if (is_thumb)
  902.     return_addr |= 1;

  904.   return return_addr;
  905. }


  908. /* Insert a single step breakpoint at the next executed instruction.  */

  910. static int
  911. ‌arm_linux_software_single_step (struct frame_info *frame)
  912. {
  913.   struct gdbarch *gdbarch = get_frame_arch (frame);
  914.   struct address_space *aspace = get_frame_address_space (frame);
  915.   CORE_ADDR next_pc;

  917.   if (arm_deal_with_atomic_sequence (frame))
  918.     return 1;

  920.   next_pc = arm_get_next_pc (frame, get_frame_pc (frame));

  922.   /* The Linux kernel offers some user-mode helpers in a high page.  We can
  923.      not read this page (as of 2.6.23), and even if we could then we couldn't
  924.      set breakpoints in it, and even if we could then the atomic operations
  925.      would fail when interrupted.  They are all called as functions and return
  926.      to the address in LR, so step to there instead.  */
  927.   if (next_pc > 0xffff0000)
  928.     next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);

  930.   arm_insert_single_step_breakpoint (gdbarch, aspace, next_pc);

  932.   return 1;
  933. }

  935. /* Support for displaced stepping of Linux SVC instructions.  */

  937. static void
  938. ‌arm_linux_cleanup_svc (struct gdbarch *gdbarch,
  939.                        struct regcache *regs,
  940.                        struct displaced_step_closure *dsc)
  941. {
  942.   CORE_ADDR from = dsc->insn_addr;
  943.   ULONGEST apparent_pc;
  944.   int within_scratch;

  946.   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);

  948.   within_scratch = (apparent_pc >= dsc->scratch_base
  949.                     && apparent_pc < (dsc->scratch_base
  950.                                       + DISPLACED_MODIFIED_INSNS * 4 + 4));

  952.   if (debug_displaced)
  953.     {
  954.       fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
  955.                           "SVC step ", (unsigned long) apparent_pc);
  956.       if (within_scratch)
  957.         fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
  958.       else
  959.         fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
  960.     }

  962.   if (within_scratch)
  963.     displaced_write_reg (regs, dsc, ARM_PC_REGNUM, from + 4, BRANCH_WRITE_PC);
  964. }

  966. static int
  967. ‌arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
  968.                     struct displaced_step_closure *dsc)
  969. {
  970.   CORE_ADDR return_to = 0;

  972.   struct frame_info *frame;
  973.   unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
  974.   int is_sigreturn = 0;
  975.   int is_thumb;

  977.   frame = get_current_frame ();

  979.   is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
  980.                                                  &return_to, &is_thumb);
  981.   if (is_sigreturn)
  982.     {
  983.           struct symtab_and_line sal;

  985.           if (debug_displaced)
  986.             fprintf_unfiltered (gdb_stdlog, "displaced: found "
  987.               "sigreturn/rt_sigreturn SVC call.  PC in frame = %lx\n",
  988.               (unsigned long) get_frame_pc (frame));

  990.           if (debug_displaced)
  991.             fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx.  "
  992.               "Setting momentary breakpoint.\n", (unsigned long) return_to);

  994.           gdb_assert (inferior_thread ()->control.step_resume_breakpoint
  995.                       == NULL);

  997.           sal = find_pc_line (return_to, 0);
  998.           sal.pc = return_to;
  999.           sal.section = find_pc_overlay (return_to);
  1000.           sal.explicit_pc = 1;

  1002.           frame = get_prev_frame (frame);

  1004.           if (frame)
  1005.             {
  1006.               inferior_thread ()->control.step_resume_breakpoint
  1007.                 = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
  1008.                                             bp_step_resume);

  1010.               /* set_momentary_breakpoint invalidates FRAME.  */
  1011.               frame = NULL;

  1013.               /* We need to make sure we actually insert the momentary
  1014.                  breakpoint set above.  */
  1015.               insert_breakpoints ();
  1016.             }
  1017.           else if (debug_displaced)
  1018.             fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
  1019.                                 "frame to set momentary breakpoint for "
  1020.                                 "sigreturn/rt_sigreturn\n");
  1021.         }
  1022.       else if (debug_displaced)
  1023.         fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
  1024.                             "SVC call not in signal trampoline frame\n");


  1027.   /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
  1028.                   location, else nothing.
  1029.      Insn: unmodified svc.
  1030.      Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
  1031.               else leave pc alone.  */


  1034.   dsc->cleanup = &arm_linux_cleanup_svc;
  1035.   /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
  1036.      instruction.  */
  1037.   dsc->wrote_to_pc = 1;

  1039.   return 0;
  1040. }


  1043. /* The following two functions implement single-stepping over calls to Linux
  1044.    kernel helper routines, which perform e.g. atomic operations on architecture
  1045.    variants which don't support them natively.

  1047.    When this function is called, the PC will be pointing at the kernel helper
  1048.    (at an address inaccessible to GDB), and r14 will point to the return
  1049.    address.  Displaced stepping always executes code in the copy area:
  1050.    so, make the copy-area instruction branch back to the kernel helper (the
  1051.    "from" address), and make r14 point to the breakpoint in the copy area.  In
  1052.    that way, we regain control once the kernel helper returns, and can clean
  1053.    up appropriately (as if we had just returned from the kernel helper as it
  1054.    would have been called from the non-displaced location).  */

  1056. static void
  1057. ‌cleanup_kernel_helper_return (struct gdbarch *gdbarch,
  1058.                               struct regcache *regs,
  1059.                               struct displaced_step_closure *dsc)
  1060. {
  1061.   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
  1062.   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
  1063. }

  1065. static void
  1066. ‌arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
  1067.                                 CORE_ADDR to, struct regcache *regs,
  1068.                                 struct displaced_step_closure *dsc)
  1069. {
  1070.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

  1072.   dsc->numinsns = 1;
  1073.   dsc->insn_addr = from;
  1074.   dsc->cleanup = &cleanup_kernel_helper_return;
  1075.   /* Say we wrote to the PC, else cleanup will set PC to the next
  1076.      instruction in the helper, which isn't helpful.  */
  1077.   dsc->wrote_to_pc = 1;

  1079.   /* Preparation: tmp[0] <- r14
  1080.                   r14 <- <scratch space>+4
  1081.                   *(<scratch space>+8) <- from
  1082.      Insn: ldr pc, [r14, #4]
  1083.      Cleanup: r14 <- tmp[0], pc <- tmp[0].  */

  1085.   dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM);
  1086.   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
  1087.                        CANNOT_WRITE_PC);
  1088.   write_memory_unsigned_integer (to + 8, 4, byte_order, from);

  1090.   dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
  1091. }

  1093. /* Linux-specific displaced step instruction copying function.  Detects when
  1094.    the program has stepped into a Linux kernel helper routine (which must be
  1095.    handled as a special case), falling back to arm_displaced_step_copy_insn()
  1096.    if it hasn't.  */

  1098. static struct displaced_step_closure *
  1099. ‌arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
  1100.                                     CORE_ADDR from, CORE_ADDR to,
  1101.                                     struct regcache *regs)
  1102. {
  1103.   struct displaced_step_closure *dsc
  1104.     = xmalloc (sizeof (struct displaced_step_closure));

  1106.   /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
  1107.      stop at the return location.  */
  1108.   if (from > 0xffff0000)
  1109.     {
  1110.       if (debug_displaced)
  1111.         fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
  1112.                             "at %.8lx\n", (unsigned long) from);

  1114.       arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
  1115.     }
  1116.   else
  1117.     {
  1118.       /* Override the default handling of SVC instructions.  */
  1119.       dsc->u.svc.copy_svc_os = arm_linux_copy_svc;

  1121.       arm_process_displaced_insn (gdbarch, from, to, regs, dsc);
  1122.     }

  1124.   arm_displaced_init_closure (gdbarch, from, to, dsc);

  1126.   return dsc;
  1127. }

  1129. /* Implementation of `gdbarch_stap_is_single_operand', as defined in
  1130.    gdbarch.h.  */

  1132. static int
  1133. ‌arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
  1134. {
  1135.   return (*s == '#' || *s == '$' || isdigit (*s) /* Literal number.  */
  1136.           || *s == '[' /* Register indirection or
  1137.                           displacement.  */
  1138.           || isalpha (*s)); /* Register value.  */
  1139. }

  1141. /* This routine is used to parse a special token in ARM's assembly.

  1143.    The special tokens parsed by it are:

  1145.       - Register displacement (e.g, [fp, #-8])

  1147.    It returns one if the special token has been parsed successfully,
  1148.    or zero if the current token is not considered special.  */

  1150. static int
  1151. ‌arm_stap_parse_special_token (struct gdbarch *gdbarch,
  1152.                               struct stap_parse_info *p)
  1153. {
  1154.   if (*p->arg == '[')
  1155.     {
  1156.       /* Temporary holder for lookahead.  */
  1157.       const char *tmp = p->arg;
  1158.       char *endp;
  1159.       /* Used to save the register name.  */
  1160.       const char *start;
  1161.       char *regname;
  1162.       int len, offset;
  1163.       int got_minus = 0;
  1164.       long displacement;
  1165.       struct stoken str;

  1167.       ++tmp;
  1168.       start = tmp;

  1170.       /* Register name.  */
  1171.       while (isalnum (*tmp))
  1172.         ++tmp;

  1174.       if (*tmp != ',')
  1175.         return 0;

  1177.       len = tmp - start;
  1178.       regname = alloca (len + 2);

  1180.       offset = 0;
  1181.       if (isdigit (*start))
  1182.         {
  1183.           /* If we are dealing with a register whose name begins with a
  1184.              digit, it means we should prefix the name with the letter
  1185.              `r', because GDB expects this name pattern.  Otherwise (e.g.,
  1186.              we are dealing with the register `fp'), we don't need to
  1187.              add such a prefix.  */
  1188.           regname[0] = 'r';
  1189.           offset = 1;
  1190.         }

  1192.       strncpy (regname + offset, start, len);
  1193.       len += offset;
  1194.       regname[len] = '\0';

  1196.       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
  1197.         error (_("Invalid register name `%s' on expression `%s'."),
  1198.                regname, p->saved_arg);

  1200.       ++tmp;
  1201.       tmp = skip_spaces_const (tmp);
  1202.       if (*tmp == '#' || *tmp == '$')
  1203.         ++tmp;

  1205.       if (*tmp == '-')
  1206.         {
  1207.           ++tmp;
  1208.           got_minus = 1;
  1209.         }

  1211.       displacement = strtol (tmp, &endp, 10);
  1212.       tmp = endp;

  1214.       /* Skipping last `]'.  */
  1215.       if (*tmp++ != ']')
  1216.         return 0;

  1218.       /* The displacement.  */
  1219.       write_exp_elt_opcode (&p->pstate, OP_LONG);
  1220.       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
  1221.       write_exp_elt_longcst (&p->pstate, displacement);
  1222.       write_exp_elt_opcode (&p->pstate, OP_LONG);
  1223.       if (got_minus)
  1224.         write_exp_elt_opcode (&p->pstate, UNOP_NEG);

  1226.       /* The register name.  */
  1227.       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
  1228.       str.ptr = regname;
  1229.       str.length = len;
  1230.       write_exp_string (&p->pstate, str);
  1231.       write_exp_elt_opcode (&p->pstate, OP_REGISTER);

  1233.       write_exp_elt_opcode (&p->pstate, BINOP_ADD);

  1235.       /* Casting to the expected type.  */
  1236.       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
  1237.       write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
  1238.       write_exp_elt_opcode (&p->pstate, UNOP_CAST);

  1240.       write_exp_elt_opcode (&p->pstate, UNOP_IND);

  1242.       p->arg = tmp;
  1243.     }
  1244.   else
  1245.     return 0;

  1247.   return 1;
  1248. }

  1250. /* ARM process record-replay constructs: syscall, signal etc.  */

  1252. ‌struct linux_record_tdep arm_linux_record_tdep;

  1254. /* arm_canonicalize_syscall maps from the native arm Linux set
  1255.    of syscall ids into a canonical set of syscall ids used by
  1256.    process record.  */

  1258. static enum gdb_syscall
  1259. ‌arm_canonicalize_syscall (int syscall)
  1260. {
  1261.   enum { sys_process_vm_writev = 377 };

  1263.   if (syscall <= gdb_sys_sched_getaffinity)
  1264.     return syscall;
  1265.   else if (syscall >= 243 && syscall <= 247)
  1266.     return syscall + 2;
  1267.   else if (syscall >= 248 && syscall <= 253)
  1268.     return syscall + 4;

  1270.   return -1;
  1271. }

  1273. /* Record all registers but PC register for process-record.  */

  1275. static int
  1276. ‌arm_all_but_pc_registers_record (struct regcache *regcache)
  1277. {
  1278.   int i;

  1280.   for (i = 0; i < ARM_PC_REGNUM; i++)
  1281.     {
  1282.       if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i))
  1283.         return -1;
  1284.     }

  1286.   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
  1287.     return -1;

  1289.   return 0;
  1290. }

  1292. /* Handler for arm system call instruction recording.  */

  1294. static int
  1295. ‌arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number)
  1296. {
  1297.   int ret = 0;
  1298.   enum gdb_syscall syscall_gdb;

  1300.   syscall_gdb = arm_canonicalize_syscall (svc_number);

  1302.   if (syscall_gdb < 0)
  1303.     {
  1304.       printf_unfiltered (_("Process record and replay target doesn't "
  1305.                            "support syscall number %s\n"),
  1306.                            plongest (svc_number));
  1307.       return -1;
  1308.     }

  1310.   if (syscall_gdb == gdb_sys_sigreturn
  1311.       || syscall_gdb == gdb_sys_rt_sigreturn)
  1312.    {
  1313.      if (arm_all_but_pc_registers_record (regcache))
  1314.        return -1;
  1315.      return 0;
  1316.    }

  1318.   ret = record_linux_system_call (syscall_gdb, regcache,
  1319.                                   &arm_linux_record_tdep);
  1320.   if (ret != 0)
  1321.     return ret;

  1323.   /* Record the return value of the system call.  */
  1324.   if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM))
  1325.     return -1;
  1326.   /* Record LR.  */
  1327.   if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM))
  1328.     return -1;
  1329.   /* Record CPSR.  */
  1330.   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
  1331.     return -1;

  1333.   return 0;
  1334. }

  1336. /* Implement the skip_trampoline_code gdbarch method.  */

  1338. static CORE_ADDR
  1339. ‌arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
  1340. {
  1341.   CORE_ADDR target_pc = arm_skip_stub (frame, pc);

  1343.   if (target_pc != 0)
  1344.     return target_pc;

  1346.   return find_solib_trampoline_target (frame, pc);
  1347. }

  1349. static void
  1350. ‌arm_linux_init_abi (struct gdbarch_info info,
  1351.                     struct gdbarch *gdbarch)
  1352. {
  1353.   static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL };
  1354.   static const char *const stap_register_prefixes[] = { "r", NULL };
  1355.   static const char *const stap_register_indirection_prefixes[] = { "[",
  1356.                                                                     NULL };
  1357.   static const char *const stap_register_indirection_suffixes[] = { "]",
  1358.                                                                     NULL };
  1359.   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);

  1361.   linux_init_abi (info, gdbarch);

  1363.   tdep->lowest_pc = 0x8000;
  1364.   if (info.byte_order_for_code == BFD_ENDIAN_BIG)
  1365.     {
  1366.       if (tdep->arm_abi == ARM_ABI_AAPCS)
  1367.         tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
  1368.       else
  1369.         tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
  1370.       tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
  1371.       tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
  1372.     }
  1373.   else
  1374.     {
  1375.       if (tdep->arm_abi == ARM_ABI_AAPCS)
  1376.         tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
  1377.       else
  1378.         tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
  1379.       tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
  1380.       tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
  1381.     }
  1382.   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
  1383.   tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
  1384.   tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);

  1386.   if (tdep->fp_model == ARM_FLOAT_AUTO)
  1387.     tdep->fp_model = ARM_FLOAT_FPA;

  1389.   switch (tdep->fp_model)
  1390.     {
  1391.     case ARM_FLOAT_FPA:
  1392.       tdep->jb_pc = ARM_LINUX_JB_PC_FPA;
  1393.       break;
  1394.     case ARM_FLOAT_SOFT_FPA:
  1395.     case ARM_FLOAT_SOFT_VFP:
  1396.     case ARM_FLOAT_VFP:
  1397.       tdep->jb_pc = ARM_LINUX_JB_PC_EABI;
  1398.       break;
  1399.     default:
  1400.       internal_error
  1401.         (__FILE__, __LINE__,
  1402.          _("arm_linux_init_abi: Floating point model not supported"));
  1403.       break;
  1404.     }
  1405.   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;

  1407.   set_solib_svr4_fetch_link_map_offsets
  1408.     (gdbarch, svr4_ilp32_fetch_link_map_offsets);

  1410.   /* Single stepping.  */
  1411.   set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);

  1413.   /* Shared library handling.  */
  1414.   set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code);
  1415.   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);

  1417.   /* Enable TLS support.  */
  1418.   set_gdbarch_fetch_tls_load_module_address (gdbarch,
  1419.                                              svr4_fetch_objfile_link_map);

  1421.   tramp_frame_prepend_unwinder (gdbarch,
  1422.                                 &arm_linux_sigreturn_tramp_frame);
  1423.   tramp_frame_prepend_unwinder (gdbarch,
  1424.                                 &arm_linux_rt_sigreturn_tramp_frame);
  1425.   tramp_frame_prepend_unwinder (gdbarch,
  1426.                                 &arm_eabi_linux_sigreturn_tramp_frame);
  1427.   tramp_frame_prepend_unwinder (gdbarch,
  1428.                                 &arm_eabi_linux_rt_sigreturn_tramp_frame);
  1429.   tramp_frame_prepend_unwinder (gdbarch,
  1430.                                 &thumb2_eabi_linux_sigreturn_tramp_frame);
  1431.   tramp_frame_prepend_unwinder (gdbarch,
  1432.                                 &thumb2_eabi_linux_rt_sigreturn_tramp_frame);
  1433.   tramp_frame_prepend_unwinder (gdbarch,
  1434.                                 &arm_linux_restart_syscall_tramp_frame);
  1435.   tramp_frame_prepend_unwinder (gdbarch,
  1436.                                 &arm_kernel_linux_restart_syscall_tramp_frame);

  1438.   /* Core file support.  */
  1439.   set_gdbarch_iterate_over_regset_sections
  1440.     (gdbarch, arm_linux_iterate_over_regset_sections);
  1441.   set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description);

  1443.   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);

  1445.   /* Displaced stepping.  */
  1446.   set_gdbarch_displaced_step_copy_insn (gdbarch,
  1447.                                         arm_linux_displaced_step_copy_insn);
  1448.   set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
  1449.   set_gdbarch_displaced_step_free_closure (gdbarch,
  1450.                                            simple_displaced_step_free_closure);
  1451.   set_gdbarch_displaced_step_location (gdbarch, displaced_step_at_entry_point);

  1453.   /* Reversible debugging, process record.  */
  1454.   set_gdbarch_process_record (gdbarch, arm_process_record);

  1456.   /* SystemTap functions.  */
  1457.   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
  1458.   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
  1459.   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
  1460.                                           stap_register_indirection_prefixes);
  1461.   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
  1462.                                           stap_register_indirection_suffixes);
  1463.   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
  1464.   set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand);
  1465.   set_gdbarch_stap_parse_special_token (gdbarch,
  1466.                                         arm_stap_parse_special_token);

  1468.   tdep->syscall_next_pc = arm_linux_syscall_next_pc;

  1470.   /* `catch syscall' */
  1471.   set_xml_syscall_file_name (gdbarch, "syscalls/arm-linux.xml");
  1472.   set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number);

  1474.   /* Syscall record.  */
  1475.   tdep->arm_syscall_record = arm_linux_syscall_record;

  1477.   /* Initialize the arm_linux_record_tdep.  */
  1478.   /* These values are the size of the type that will be used in a system
  1479.      call.  They are obtained from Linux Kernel source.  */
  1480.   arm_linux_record_tdep.size_pointer
  1481.     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
  1482.   arm_linux_record_tdep.size__old_kernel_stat = 32;
  1483.   arm_linux_record_tdep.size_tms = 16;
  1484.   arm_linux_record_tdep.size_loff_t = 8;
  1485.   arm_linux_record_tdep.size_flock = 16;
  1486.   arm_linux_record_tdep.size_oldold_utsname = 45;
  1487.   arm_linux_record_tdep.size_ustat = 20;
  1488.   arm_linux_record_tdep.size_old_sigaction = 140;
  1489.   arm_linux_record_tdep.size_old_sigset_t = 128;
  1490.   arm_linux_record_tdep.size_rlimit = 8;
  1491.   arm_linux_record_tdep.size_rusage = 72;
  1492.   arm_linux_record_tdep.size_timeval = 8;
  1493.   arm_linux_record_tdep.size_timezone = 8;
  1494.   arm_linux_record_tdep.size_old_gid_t = 2;
  1495.   arm_linux_record_tdep.size_old_uid_t = 2;
  1496.   arm_linux_record_tdep.size_fd_set = 128;
  1497.   arm_linux_record_tdep.size_dirent = 268;
  1498.   arm_linux_record_tdep.size_dirent64 = 276;
  1499.   arm_linux_record_tdep.size_statfs = 64;
  1500.   arm_linux_record_tdep.size_statfs64 = 84;
  1501.   arm_linux_record_tdep.size_sockaddr = 16;
  1502.   arm_linux_record_tdep.size_int
  1503.     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
  1504.   arm_linux_record_tdep.size_long
  1505.     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
  1506.   arm_linux_record_tdep.size_ulong
  1507.     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
  1508.   arm_linux_record_tdep.size_msghdr = 28;
  1509.   arm_linux_record_tdep.size_itimerval = 16;
  1510.   arm_linux_record_tdep.size_stat = 88;
  1511.   arm_linux_record_tdep.size_old_utsname = 325;
  1512.   arm_linux_record_tdep.size_sysinfo = 64;
  1513.   arm_linux_record_tdep.size_msqid_ds = 88;
  1514.   arm_linux_record_tdep.size_shmid_ds = 84;
  1515.   arm_linux_record_tdep.size_new_utsname = 390;
  1516.   arm_linux_record_tdep.size_timex = 128;
  1517.   arm_linux_record_tdep.size_mem_dqinfo = 24;
  1518.   arm_linux_record_tdep.size_if_dqblk = 68;
  1519.   arm_linux_record_tdep.size_fs_quota_stat = 68;
  1520.   arm_linux_record_tdep.size_timespec = 8;
  1521.   arm_linux_record_tdep.size_pollfd = 8;
  1522.   arm_linux_record_tdep.size_NFS_FHSIZE = 32;
  1523.   arm_linux_record_tdep.size_knfsd_fh = 132;
  1524.   arm_linux_record_tdep.size_TASK_COMM_LEN = 16;
  1525.   arm_linux_record_tdep.size_sigaction = 140;
  1526.   arm_linux_record_tdep.size_sigset_t = 8;
  1527.   arm_linux_record_tdep.size_siginfo_t = 128;
  1528.   arm_linux_record_tdep.size_cap_user_data_t = 12;
  1529.   arm_linux_record_tdep.size_stack_t = 12;
  1530.   arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long;
  1531.   arm_linux_record_tdep.size_stat64 = 96;
  1532.   arm_linux_record_tdep.size_gid_t = 2;
  1533.   arm_linux_record_tdep.size_uid_t = 2;
  1534.   arm_linux_record_tdep.size_PAGE_SIZE = 4096;
  1535.   arm_linux_record_tdep.size_flock64 = 24;
  1536.   arm_linux_record_tdep.size_user_desc = 16;
  1537.   arm_linux_record_tdep.size_io_event = 32;
  1538.   arm_linux_record_tdep.size_iocb = 64;
  1539.   arm_linux_record_tdep.size_epoll_event = 12;
  1540.   arm_linux_record_tdep.size_itimerspec
  1541.     = arm_linux_record_tdep.size_timespec * 2;
  1542.   arm_linux_record_tdep.size_mq_attr = 32;
  1543.   arm_linux_record_tdep.size_siginfo = 128;
  1544.   arm_linux_record_tdep.size_termios = 36;
  1545.   arm_linux_record_tdep.size_termios2 = 44;
  1546.   arm_linux_record_tdep.size_pid_t = 4;
  1547.   arm_linux_record_tdep.size_winsize = 8;
  1548.   arm_linux_record_tdep.size_serial_struct = 60;
  1549.   arm_linux_record_tdep.size_serial_icounter_struct = 80;
  1550.   arm_linux_record_tdep.size_hayes_esp_config = 12;
  1551.   arm_linux_record_tdep.size_size_t = 4;
  1552.   arm_linux_record_tdep.size_iovec = 8;

  1554.   /* These values are the second argument of system call "sys_ioctl".
  1555.      They are obtained from Linux Kernel source.  */
  1556.   arm_linux_record_tdep.ioctl_TCGETS = 0x5401;
  1557.   arm_linux_record_tdep.ioctl_TCSETS = 0x5402;
  1558.   arm_linux_record_tdep.ioctl_TCSETSW = 0x5403;
  1559.   arm_linux_record_tdep.ioctl_TCSETSF = 0x5404;
  1560.   arm_linux_record_tdep.ioctl_TCGETA = 0x5405;
  1561.   arm_linux_record_tdep.ioctl_TCSETA = 0x5406;
  1562.   arm_linux_record_tdep.ioctl_TCSETAW = 0x5407;
  1563.   arm_linux_record_tdep.ioctl_TCSETAF = 0x5408;
  1564.   arm_linux_record_tdep.ioctl_TCSBRK = 0x5409;
  1565.   arm_linux_record_tdep.ioctl_TCXONC = 0x540a;
  1566.   arm_linux_record_tdep.ioctl_TCFLSH = 0x540b;
  1567.   arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
  1568.   arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
  1569.   arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
  1570.   arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
  1571.   arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
  1572.   arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
  1573.   arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
  1574.   arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
  1575.   arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
  1576.   arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
  1577.   arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
  1578.   arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
  1579.   arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
  1580.   arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
  1581.   arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
  1582.   arm_linux_record_tdep.ioctl_FIONREAD = 0x541b;
  1583.   arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD;
  1584.   arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
  1585.   arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
  1586.   arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
  1587.   arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
  1588.   arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
  1589.   arm_linux_record_tdep.ioctl_FIONBIO = 0x5421;
  1590.   arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
  1591.   arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
  1592.   arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
  1593.   arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
  1594.   arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
  1595.   arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
  1596.   arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
  1597.   arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
  1598.   arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
  1599.   arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
  1600.   arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
  1601.   arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
  1602.   arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
  1603.   arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
  1604.   arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
  1605.   arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
  1606.   arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
  1607.   arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
  1608.   arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
  1609.   arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
  1610.   arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
  1611.   arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
  1612.   arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
  1613.   arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
  1614.   arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
  1615.   arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
  1616.   arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
  1617.   arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
  1618.   arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
  1619.   arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
  1620.   arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;

  1622.   /* These values are the second argument of system call "sys_fcntl"
  1623.      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
  1624.   arm_linux_record_tdep.fcntl_F_GETLK = 5;
  1625.   arm_linux_record_tdep.fcntl_F_GETLK64 = 12;
  1626.   arm_linux_record_tdep.fcntl_F_SETLK64 = 13;
  1627.   arm_linux_record_tdep.fcntl_F_SETLKW64 = 14;

  1629.   arm_linux_record_tdep.arg1 = ARM_A1_REGNUM + 1;
  1630.   arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 2;
  1631.   arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 3;
  1632.   arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3;
  1633. }

  1635. /* Provide a prototype to silence -Wmissing-prototypes.  */
  1636. extern initialize_file_ftype _initialize_arm_linux_tdep;

  1638. void
  1639. ‌_initialize_arm_linux_tdep (void)
  1640. {
  1641.   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
  1642.                           arm_linux_init_abi);
  1643. }