gdb/arm-linux-tdep.c

   1 /* GNU/Linux on ARM target support.
   2
   3    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   4    2009 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "target.h"
  23 #include "value.h"
  24 #include "gdbtypes.h"
  25 #include "floatformat.h"
  26 #include "gdbcore.h"
  27 #include "frame.h"
  28 #include "regcache.h"
  29 #include "doublest.h"
  30 #include "solib-svr4.h"
  31 #include "osabi.h"
  32 #include "regset.h"
  33 #include "trad-frame.h"
  34 #include "tramp-frame.h"
  35 #include "breakpoint.h"
  36
  37 #include "arm-tdep.h"
  38 #include "arm-linux-tdep.h"
  39 #include "linux-tdep.h"
  40 #include "glibc-tdep.h"
  41
  42 #include "gdb_string.h"
  43
  44 extern int arm_apcs_32;
  45
  46 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
  47    is to execute a particular software interrupt, rather than use a
  48    particular undefined instruction to provoke a trap.  Upon exection
  49    of the software interrupt the kernel stops the inferior with a
  50    SIGTRAP, and wakes the debugger.  */
  51
  52 static const char arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
  53
  54 static const char arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
  55
  56 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
  57    the operand of the swi if old-ABI compatibility is disabled.  Therefore,
  58    use an undefined instruction instead.  This is supported as of kernel
  59    version 2.5.70 (May 2003), so should be a safe assumption for EABI
  60    binaries.  */
  61
  62 static const char eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
  63
  64 static const char eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
  65
  66 /* All the kernels which support Thumb support using a specific undefined
  67    instruction for the Thumb breakpoint.  */
  68
  69 static const char arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
  70
  71 static const char arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
  72
  73 /* Description of the longjmp buffer.  */
  74 #define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_SIZE
  75 #define ARM_LINUX_JB_PC                 21
  76
  77 /*
  78    Dynamic Linking on ARM GNU/Linux
  79    --------------------------------
  80
  81    Note: PLT = procedure linkage table
  82    GOT = global offset table
  83
  84    As much as possible, ELF dynamic linking defers the resolution of
  85    jump/call addresses until the last minute. The technique used is
  86    inspired by the i386 ELF design, and is based on the following
  87    constraints.
  88
  89    1) The calling technique should not force a change in the assembly
  90    code produced for apps; it MAY cause changes in the way assembly
  91    code is produced for position independent code (i.e. shared
  92    libraries).
  93
  94    2) The technique must be such that all executable areas must not be
  95    modified; and any modified areas must not be executed.
  96
  97    To do this, there are three steps involved in a typical jump:
  98
  99    1) in the code
 100    2) through the PLT
 101    3) using a pointer from the GOT
 102
 103    When the executable or library is first loaded, each GOT entry is
 104    initialized to point to the code which implements dynamic name
 105    resolution and code finding.  This is normally a function in the
 106    program interpreter (on ARM GNU/Linux this is usually
 107    ld-linux.so.2, but it does not have to be).  On the first
 108    invocation, the function is located and the GOT entry is replaced
 109    with the real function address.  Subsequent calls go through steps
 110    1, 2 and 3 and end up calling the real code.
 111
 112    1) In the code:
 113
 114    b    function_call
 115    bl   function_call
 116
 117    This is typical ARM code using the 26 bit relative branch or branch
 118    and link instructions.  The target of the instruction
 119    (function_call is usually the address of the function to be called.
 120    In position independent code, the target of the instruction is
 121    actually an entry in the PLT when calling functions in a shared
 122    library.  Note that this call is identical to a normal function
 123    call, only the target differs.
 124
 125    2) In the PLT:
 126
 127    The PLT is a synthetic area, created by the linker. It exists in
 128    both executables and libraries. It is an array of stubs, one per
 129    imported function call. It looks like this:
 130
 131    PLT[0]:
 132    str     lr, [sp, #-4]!       @push the return address (lr)
 133    ldr     lr, [pc, #16]   @load from 6 words ahead
 134    add     lr, pc, lr      @form an address for GOT[0]
 135    ldr     pc, [lr, #8]!   @jump to the contents of that addr
 136
 137    The return address (lr) is pushed on the stack and used for
 138    calculations.  The load on the second line loads the lr with
 139    &GOT[3] - . - 20.  The addition on the third leaves:
 140
 141    lr = (&GOT[3] - . - 20) + (. + 8)
 142    lr = (&GOT[3] - 12)
 143    lr = &GOT[0]
 144
 145    On the fourth line, the pc and lr are both updated, so that:
 146
 147    pc = GOT[2]
 148    lr = &GOT[0] + 8
 149    = &GOT[2]
 150
 151    NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
 152    "tight", but allows us to keep all the PLT entries the same size.
 153
 154    PLT[n+1]:
 155    ldr     ip, [pc, #4]    @load offset from gotoff
 156    add     ip, pc, ip      @add the offset to the pc
 157    ldr     pc, [ip]        @jump to that address
 158    gotoff: .word   GOT[n+3] - .
 159
 160    The load on the first line, gets an offset from the fourth word of
 161    the PLT entry.  The add on the second line makes ip = &GOT[n+3],
 162    which contains either a pointer to PLT[0] (the fixup trampoline) or
 163    a pointer to the actual code.
 164
 165    3) In the GOT:
 166
 167    The GOT contains helper pointers for both code (PLT) fixups and
 168    data fixups.  The first 3 entries of the GOT are special. The next
 169    M entries (where M is the number of entries in the PLT) belong to
 170    the PLT fixups. The next D (all remaining) entries belong to
 171    various data fixups. The actual size of the GOT is 3 + M + D.
 172
 173    The GOT is also a synthetic area, created by the linker. It exists
 174    in both executables and libraries.  When the GOT is first
 175    initialized , all the GOT entries relating to PLT fixups are
 176    pointing to code back at PLT[0].
 177
 178    The special entries in the GOT are:
 179
 180    GOT[0] = linked list pointer used by the dynamic loader
 181    GOT[1] = pointer to the reloc table for this module
 182    GOT[2] = pointer to the fixup/resolver code
 183
 184    The first invocation of function call comes through and uses the
 185    fixup/resolver code.  On the entry to the fixup/resolver code:
 186
 187    ip = &GOT[n+3]
 188    lr = &GOT[2]
 189    stack[0] = return address (lr) of the function call
 190    [r0, r1, r2, r3] are still the arguments to the function call
 191
 192    This is enough information for the fixup/resolver code to work
 193    with.  Before the fixup/resolver code returns, it actually calls
 194    the requested function and repairs &GOT[n+3].  */
 195
 196 /* The constants below were determined by examining the following files
 197    in the linux kernel sources:
 198
 199       arch/arm/kernel/signal.c
 200           - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
 201       include/asm-arm/unistd.h
 202           - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
 203
 204 #define ARM_LINUX_SIGRETURN_INSTR       0xef900077
 205 #define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
 206
 207 /* For ARM EABI, the syscall number is not in the SWI instruction
 208    (instead it is loaded into r7).  We recognize the pattern that
 209    glibc uses...  alternatively, we could arrange to do this by
 210    function name, but they are not always exported.  */
 211 #define ARM_SET_R7_SIGRETURN            0xe3a07077
 212 #define ARM_SET_R7_RT_SIGRETURN         0xe3a070ad
 213 #define ARM_EABI_SYSCALL                0xef000000
 214
 215 static void
 216 arm_linux_sigtramp_cache (struct frame_info *this_frame,
 217                           struct trad_frame_cache *this_cache,
 218                           CORE_ADDR func, int regs_offset)
 219 {
 220   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 221   CORE_ADDR base = sp + regs_offset;
 222   int i;
 223
 224   for (i = 0; i < 16; i++)
 225     trad_frame_set_reg_addr (this_cache, i, base + i * 4);
 226
 227   trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
 228
 229   /* The VFP or iWMMXt registers may be saved on the stack, but there's
 230      no reliable way to restore them (yet).  */
 231
 232   /* Save a frame ID.  */
 233   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 234 }
 235
 236 /* There are a couple of different possible stack layouts that
 237    we need to support.
 238
 239    Before version 2.6.18, the kernel used completely independent
 240    layouts for non-RT and RT signals.  For non-RT signals the stack
 241    began directly with a struct sigcontext.  For RT signals the stack
 242    began with two redundant pointers (to the siginfo and ucontext),
 243    and then the siginfo and ucontext.
 244
 245    As of version 2.6.18, the non-RT signal frame layout starts with
 246    a ucontext and the RT signal frame starts with a siginfo and then
 247    a ucontext.  Also, the ucontext now has a designated save area
 248    for coprocessor registers.
 249
 250    For RT signals, it's easy to tell the difference: we look for
 251    pinfo, the pointer to the siginfo.  If it has the expected
 252    value, we have an old layout.  If it doesn't, we have the new
 253    layout.
 254
 255    For non-RT signals, it's a bit harder.  We need something in one
 256    layout or the other with a recognizable offset and value.  We can't
 257    use the return trampoline, because ARM usually uses SA_RESTORER,
 258    in which case the stack return trampoline is not filled in.
 259    We can't use the saved stack pointer, because sigaltstack might
 260    be in use.  So for now we guess the new layout...  */
 261
 262 /* There are three words (trap_no, error_code, oldmask) in
 263    struct sigcontext before r0.  */
 264 #define ARM_SIGCONTEXT_R0 0xc
 265
 266 /* There are five words (uc_flags, uc_link, and three for uc_stack)
 267    in the ucontext_t before the sigcontext.  */
 268 #define ARM_UCONTEXT_SIGCONTEXT 0x14
 269
 270 /* There are three elements in an rt_sigframe before the ucontext:
 271    pinfo, puc, and info.  The first two are pointers and the third
 272    is a struct siginfo, with size 128 bytes.  We could follow puc
 273    to the ucontext, but it's simpler to skip the whole thing.  */
 274 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
 275 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
 276
 277 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
 278
 279 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
 280
 281 static void
 282 arm_linux_sigreturn_init (const struct tramp_frame *self,
 283                           struct frame_info *this_frame,
 284                           struct trad_frame_cache *this_cache,
 285                           CORE_ADDR func)
 286 {
 287   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 288   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 289   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 290   ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
 291
 292   if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
 293     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 294                               ARM_UCONTEXT_SIGCONTEXT
 295                               + ARM_SIGCONTEXT_R0);
 296   else
 297     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 298                               ARM_SIGCONTEXT_R0);
 299 }
 300
 301 static void
 302 arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
 303                           struct frame_info *this_frame,
 304                           struct trad_frame_cache *this_cache,
 305                           CORE_ADDR func)
 306 {
 307   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 308   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 309   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 310   ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
 311
 312   if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
 313     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 314                               ARM_OLD_RT_SIGFRAME_UCONTEXT
 315                               + ARM_UCONTEXT_SIGCONTEXT
 316                               + ARM_SIGCONTEXT_R0);
 317   else
 318     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 319                               ARM_NEW_RT_SIGFRAME_UCONTEXT
 320                               + ARM_UCONTEXT_SIGCONTEXT
 321                               + ARM_SIGCONTEXT_R0);
 322 }
 323
 324 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
 325   SIGTRAMP_FRAME,
 326   4,
 327   {
 328     { ARM_LINUX_SIGRETURN_INSTR, -1 },
 329     { TRAMP_SENTINEL_INSN }
 330   },
 331   arm_linux_sigreturn_init
 332 };
 333
 334 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
 335   SIGTRAMP_FRAME,
 336   4,
 337   {
 338     { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
 339     { TRAMP_SENTINEL_INSN }
 340   },
 341   arm_linux_rt_sigreturn_init
 342 };
 343
 344 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
 345   SIGTRAMP_FRAME,
 346   4,
 347   {
 348     { ARM_SET_R7_SIGRETURN, -1 },
 349     { ARM_EABI_SYSCALL, -1 },
 350     { TRAMP_SENTINEL_INSN }
 351   },
 352   arm_linux_sigreturn_init
 353 };
 354
 355 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
 356   SIGTRAMP_FRAME,
 357   4,
 358   {
 359     { ARM_SET_R7_RT_SIGRETURN, -1 },
 360     { ARM_EABI_SYSCALL, -1 },
 361     { TRAMP_SENTINEL_INSN }
 362   },
 363   arm_linux_rt_sigreturn_init
 364 };
 365
 366 /* Core file and register set support.  */
 367
 368 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
 369
 370 void
 371 arm_linux_supply_gregset (const struct regset *regset,
 372                           struct regcache *regcache,
 373                           int regnum, const void *gregs_buf, size_t len)
 374 {
 375   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 376   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 377   const gdb_byte *gregs = gregs_buf;
 378   int regno;
 379   CORE_ADDR reg_pc;
 380   gdb_byte pc_buf[INT_REGISTER_SIZE];
 381
 382   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 383     if (regnum == -1 || regnum == regno)
 384       regcache_raw_supply (regcache, regno,
 385                            gregs + INT_REGISTER_SIZE * regno);
 386
 387   if (regnum == ARM_PS_REGNUM || regnum == -1)
 388     {
 389       if (arm_apcs_32)
 390         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 391                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 392       else
 393         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 394                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 395     }
 396
 397   if (regnum == ARM_PC_REGNUM || regnum == -1)
 398     {
 399       reg_pc = extract_unsigned_integer (gregs
 400                                          + INT_REGISTER_SIZE * ARM_PC_REGNUM,
 401                                          INT_REGISTER_SIZE, byte_order);
 402       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
 403       store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
 404       regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
 405     }
 406 }
 407
 408 void
 409 arm_linux_collect_gregset (const struct regset *regset,
 410                            const struct regcache *regcache,
 411                            int regnum, void *gregs_buf, size_t len)
 412 {
 413   gdb_byte *gregs = gregs_buf;
 414   int regno;
 415
 416   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 417     if (regnum == -1 || regnum == regno)
 418       regcache_raw_collect (regcache, regno,
 419                             gregs + INT_REGISTER_SIZE * regno);
 420
 421   if (regnum == ARM_PS_REGNUM || regnum == -1)
 422     {
 423       if (arm_apcs_32)
 424         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 425                               gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 426       else
 427         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 428                               gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 429     }
 430
 431   if (regnum == ARM_PC_REGNUM || regnum == -1)
 432     regcache_raw_collect (regcache, ARM_PC_REGNUM,
 433                           gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 434 }
 435
 436 /* Support for register format used by the NWFPE FPA emulator.  */
 437
 438 #define typeNone                0x00
 439 #define typeSingle              0x01
 440 #define typeDouble              0x02
 441 #define typeExtended            0x03
 442
 443 void
 444 supply_nwfpe_register (struct regcache *regcache, int regno,
 445                        const gdb_byte *regs)
 446 {
 447   const gdb_byte *reg_data;
 448   gdb_byte reg_tag;
 449   gdb_byte buf[FP_REGISTER_SIZE];
 450
 451   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 452   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 453   memset (buf, 0, FP_REGISTER_SIZE);
 454
 455   switch (reg_tag)
 456     {
 457     case typeSingle:
 458       memcpy (buf, reg_data, 4);
 459       break;
 460     case typeDouble:
 461       memcpy (buf, reg_data + 4, 4);
 462       memcpy (buf + 4, reg_data, 4);
 463       break;
 464     case typeExtended:
 465       /* We want sign and exponent, then least significant bits,
 466          then most significant.  NWFPE does sign, most, least.  */
 467       memcpy (buf, reg_data, 4);
 468       memcpy (buf + 4, reg_data + 8, 4);
 469       memcpy (buf + 8, reg_data + 4, 4);
 470       break;
 471     default:
 472       break;
 473     }
 474
 475   regcache_raw_supply (regcache, regno, buf);
 476 }
 477
 478 void
 479 collect_nwfpe_register (const struct regcache *regcache, int regno,
 480                         gdb_byte *regs)
 481 {
 482   gdb_byte *reg_data;
 483   gdb_byte reg_tag;
 484   gdb_byte buf[FP_REGISTER_SIZE];
 485
 486   regcache_raw_collect (regcache, regno, buf);
 487
 488   /* NOTE drow/2006-06-07: This code uses the tag already in the
 489      register buffer.  I've preserved that when moving the code
 490      from the native file to the target file.  But this doesn't
 491      always make sense.  */
 492
 493   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 494   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 495
 496   switch (reg_tag)
 497     {
 498     case typeSingle:
 499       memcpy (reg_data, buf, 4);
 500       break;
 501     case typeDouble:
 502       memcpy (reg_data, buf + 4, 4);
 503       memcpy (reg_data + 4, buf, 4);
 504       break;
 505     case typeExtended:
 506       memcpy (reg_data, buf, 4);
 507       memcpy (reg_data + 4, buf + 8, 4);
 508       memcpy (reg_data + 8, buf + 4, 4);
 509       break;
 510     default:
 511       break;
 512     }
 513 }
 514
 515 void
 516 arm_linux_supply_nwfpe (const struct regset *regset,
 517                         struct regcache *regcache,
 518                         int regnum, const void *regs_buf, size_t len)
 519 {
 520   const gdb_byte *regs = regs_buf;
 521   int regno;
 522
 523   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 524     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 525                          regs + NWFPE_FPSR_OFFSET);
 526
 527   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 528     if (regnum == -1 || regnum == regno)
 529       supply_nwfpe_register (regcache, regno, regs);
 530 }
 531
 532 void
 533 arm_linux_collect_nwfpe (const struct regset *regset,
 534                          const struct regcache *regcache,
 535                          int regnum, void *regs_buf, size_t len)
 536 {
 537   gdb_byte *regs = regs_buf;
 538   int regno;
 539
 540   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 541     if (regnum == -1 || regnum == regno)
 542       collect_nwfpe_register (regcache, regno, regs);
 543
 544   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 545     regcache_raw_collect (regcache, ARM_FPS_REGNUM,
 546                           regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
 547 }
 548
 549 /* Return the appropriate register set for the core section identified
 550    by SECT_NAME and SECT_SIZE.  */
 551
 552 static const struct regset *
 553 arm_linux_regset_from_core_section (struct gdbarch *gdbarch,
 554                                     const char *sect_name, size_t sect_size)
 555 {
 556   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 557
 558   if (strcmp (sect_name, ".reg") == 0
 559       && sect_size == ARM_LINUX_SIZEOF_GREGSET)
 560     {
 561       if (tdep->gregset == NULL)
 562         tdep->gregset = regset_alloc (gdbarch, arm_linux_supply_gregset,
 563                                       arm_linux_collect_gregset);
 564       return tdep->gregset;
 565     }
 566
 567   if (strcmp (sect_name, ".reg2") == 0
 568       && sect_size == ARM_LINUX_SIZEOF_NWFPE)
 569     {
 570       if (tdep->fpregset == NULL)
 571         tdep->fpregset = regset_alloc (gdbarch, arm_linux_supply_nwfpe,
 572                                        arm_linux_collect_nwfpe);
 573       return tdep->fpregset;
 574     }
 575
 576   return NULL;
 577 }
 578
 579 /* Insert a single step breakpoint at the next executed instruction.  */
 580
 581 static int
 582 arm_linux_software_single_step (struct frame_info *frame)
 583 {
 584   struct gdbarch *gdbarch = get_frame_arch (frame);
 585   CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
 586
 587   /* The Linux kernel offers some user-mode helpers in a high page.  We can
 588      not read this page (as of 2.6.23), and even if we could then we couldn't
 589      set breakpoints in it, and even if we could then the atomic operations
 590      would fail when interrupted.  They are all called as functions and return
 591      to the address in LR, so step to there instead.  */
 592   if (next_pc > 0xffff0000)
 593     next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
 594
 595   insert_single_step_breakpoint (gdbarch, next_pc);
 596
 597   return 1;
 598 }
 599
 600 static void
 601 arm_linux_init_abi (struct gdbarch_info info,
 602                     struct gdbarch *gdbarch)
 603 {
 604   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 605
 606   tdep->lowest_pc = 0x8000;
 607   if (info.byte_order == BFD_ENDIAN_BIG)
 608     {
 609       if (tdep->arm_abi == ARM_ABI_AAPCS)
 610         tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
 611       else
 612         tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
 613       tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
 614     }
 615   else
 616     {
 617       if (tdep->arm_abi == ARM_ABI_AAPCS)
 618         tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
 619       else
 620         tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
 621       tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
 622     }
 623   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
 624   tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
 625
 626   if (tdep->fp_model == ARM_FLOAT_AUTO)
 627     tdep->fp_model = ARM_FLOAT_FPA;
 628
 629   tdep->jb_pc = ARM_LINUX_JB_PC;
 630   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
 631
 632   set_solib_svr4_fetch_link_map_offsets
 633     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 634
 635   /* Single stepping.  */
 636   set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
 637
 638   /* Shared library handling.  */
 639   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 640   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 641
 642   /* Enable TLS support.  */
 643   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 644                                              svr4_fetch_objfile_link_map);
 645
 646   tramp_frame_prepend_unwinder (gdbarch,
 647                                 &arm_linux_sigreturn_tramp_frame);
 648   tramp_frame_prepend_unwinder (gdbarch,
 649                                 &arm_linux_rt_sigreturn_tramp_frame);
 650   tramp_frame_prepend_unwinder (gdbarch,
 651                                 &arm_eabi_linux_sigreturn_tramp_frame);
 652   tramp_frame_prepend_unwinder (gdbarch,
 653                                 &arm_eabi_linux_rt_sigreturn_tramp_frame);
 654
 655   /* Core file support.  */
 656   set_gdbarch_regset_from_core_section (gdbarch,
 657                                         arm_linux_regset_from_core_section);
 658
 659   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
 660 }
 661
 662 /* Provide a prototype to silence -Wmissing-prototypes.  */
 663 extern initialize_file_ftype _initialize_arm_linux_tdep;
 664
 665 void
 666 _initialize_arm_linux_tdep (void)
 667 {
 668   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
 669                           arm_linux_init_abi);
 670 }