gdb/arm-linux-tdep.c

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