gdb/arm-linux-tdep.c

   1 /* GNU/Linux on ARM target support.
   2
   3    Copyright (C) 1999-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "target.h"
  22 #include "value.h"
  23 #include "gdbtypes.h"
  24 #include "floatformat.h"
  25 #include "gdbcore.h"
  26 #include "frame.h"
  27 #include "regcache.h"
  28 #include "doublest.h"
  29 #include "solib-svr4.h"
  30 #include "osabi.h"
  31 #include "regset.h"
  32 #include "trad-frame.h"
  33 #include "tramp-frame.h"
  34 #include "breakpoint.h"
  35 #include "auxv.h"
  36 #include "xml-syscall.h"
  37
  38 #include "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"
  47
  48 #include "record-full.h"
  49 #include "linux-record.h"
  50
  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 #include <string.h>
  58
  59 extern int arm_apcs_32;
  60
  61 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
  62    is to execute a particular software interrupt, rather than use a
  63    particular undefined instruction to provoke a trap.  Upon exection
  64    of the software interrupt the kernel stops the inferior with a
  65    SIGTRAP, and wakes the debugger.  */
  66
  67 static const gdb_byte arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
  68
  69 static const gdb_byte arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
  70
  71 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
  72    the operand of the swi if old-ABI compatibility is disabled.  Therefore,
  73    use an undefined instruction instead.  This is supported as of kernel
  74    version 2.5.70 (May 2003), so should be a safe assumption for EABI
  75    binaries.  */
  76
  77 static const gdb_byte eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
  78
  79 static const gdb_byte eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
  80
  81 /* All the kernels which support Thumb support using a specific undefined
  82    instruction for the Thumb breakpoint.  */
  83
  84 static const gdb_byte arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
  85
  86 static const gdb_byte arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
  87
  88 /* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
  89    we must use a length-appropriate breakpoint for 32-bit Thumb
  90    instructions.  See also thumb_get_next_pc.  */
  91
  92 static const gdb_byte arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };
  93
  94 static const gdb_byte arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 };
  95
  96 /* Description of the longjmp buffer.  The buffer is treated as an array of
  97    elements of size ARM_LINUX_JB_ELEMENT_SIZE.
  98
  99    The location of saved registers in this buffer (in particular the PC
 100    to use after longjmp is called) varies depending on the ABI (in
 101    particular the FP model) and also (possibly) the C Library.
 102
 103    For glibc, eglibc, and uclibc the following holds:  If the FP model is
 104    SoftVFP or VFP (which implies EABI) then the PC is at offset 9 in the
 105    buffer.  This is also true for the SoftFPA model.  However, for the FPA
 106    model the PC is at offset 21 in the buffer.  */
 107 #define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_SIZE
 108 #define ARM_LINUX_JB_PC_FPA             21
 109 #define ARM_LINUX_JB_PC_EABI            9
 110
 111 /*
 112    Dynamic Linking on ARM GNU/Linux
 113    --------------------------------
 114
 115    Note: PLT = procedure linkage table
 116    GOT = global offset table
 117
 118    As much as possible, ELF dynamic linking defers the resolution of
 119    jump/call addresses until the last minute.  The technique used is
 120    inspired by the i386 ELF design, and is based on the following
 121    constraints.
 122
 123    1) The calling technique should not force a change in the assembly
 124    code produced for apps; it MAY cause changes in the way assembly
 125    code is produced for position independent code (i.e. shared
 126    libraries).
 127
 128    2) The technique must be such that all executable areas must not be
 129    modified; and any modified areas must not be executed.
 130
 131    To do this, there are three steps involved in a typical jump:
 132
 133    1) in the code
 134    2) through the PLT
 135    3) using a pointer from the GOT
 136
 137    When the executable or library is first loaded, each GOT entry is
 138    initialized to point to the code which implements dynamic name
 139    resolution and code finding.  This is normally a function in the
 140    program interpreter (on ARM GNU/Linux this is usually
 141    ld-linux.so.2, but it does not have to be).  On the first
 142    invocation, the function is located and the GOT entry is replaced
 143    with the real function address.  Subsequent calls go through steps
 144    1, 2 and 3 and end up calling the real code.
 145
 146    1) In the code:
 147
 148    b    function_call
 149    bl   function_call
 150
 151    This is typical ARM code using the 26 bit relative branch or branch
 152    and link instructions.  The target of the instruction
 153    (function_call is usually the address of the function to be called.
 154    In position independent code, the target of the instruction is
 155    actually an entry in the PLT when calling functions in a shared
 156    library.  Note that this call is identical to a normal function
 157    call, only the target differs.
 158
 159    2) In the PLT:
 160
 161    The PLT is a synthetic area, created by the linker.  It exists in
 162    both executables and libraries.  It is an array of stubs, one per
 163    imported function call.  It looks like this:
 164
 165    PLT[0]:
 166    str     lr, [sp, #-4]!       @push the return address (lr)
 167    ldr     lr, [pc, #16]   @load from 6 words ahead
 168    add     lr, pc, lr      @form an address for GOT[0]
 169    ldr     pc, [lr, #8]!   @jump to the contents of that addr
 170
 171    The return address (lr) is pushed on the stack and used for
 172    calculations.  The load on the second line loads the lr with
 173    &GOT[3] - . - 20.  The addition on the third leaves:
 174
 175    lr = (&GOT[3] - . - 20) + (. + 8)
 176    lr = (&GOT[3] - 12)
 177    lr = &GOT[0]
 178
 179    On the fourth line, the pc and lr are both updated, so that:
 180
 181    pc = GOT[2]
 182    lr = &GOT[0] + 8
 183    = &GOT[2]
 184
 185    NOTE: PLT[0] borrows an offset .word from PLT[1].  This is a little
 186    "tight", but allows us to keep all the PLT entries the same size.
 187
 188    PLT[n+1]:
 189    ldr     ip, [pc, #4]    @load offset from gotoff
 190    add     ip, pc, ip      @add the offset to the pc
 191    ldr     pc, [ip]        @jump to that address
 192    gotoff: .word   GOT[n+3] - .
 193
 194    The load on the first line, gets an offset from the fourth word of
 195    the PLT entry.  The add on the second line makes ip = &GOT[n+3],
 196    which contains either a pointer to PLT[0] (the fixup trampoline) or
 197    a pointer to the actual code.
 198
 199    3) In the GOT:
 200
 201    The GOT contains helper pointers for both code (PLT) fixups and
 202    data fixups.  The first 3 entries of the GOT are special.  The next
 203    M entries (where M is the number of entries in the PLT) belong to
 204    the PLT fixups.  The next D (all remaining) entries belong to
 205    various data fixups.  The actual size of the GOT is 3 + M + D.
 206
 207    The GOT is also a synthetic area, created by the linker.  It exists
 208    in both executables and libraries.  When the GOT is first
 209    initialized , all the GOT entries relating to PLT fixups are
 210    pointing to code back at PLT[0].
 211
 212    The special entries in the GOT are:
 213
 214    GOT[0] = linked list pointer used by the dynamic loader
 215    GOT[1] = pointer to the reloc table for this module
 216    GOT[2] = pointer to the fixup/resolver code
 217
 218    The first invocation of function call comes through and uses the
 219    fixup/resolver code.  On the entry to the fixup/resolver code:
 220
 221    ip = &GOT[n+3]
 222    lr = &GOT[2]
 223    stack[0] = return address (lr) of the function call
 224    [r0, r1, r2, r3] are still the arguments to the function call
 225
 226    This is enough information for the fixup/resolver code to work
 227    with.  Before the fixup/resolver code returns, it actually calls
 228    the requested function and repairs &GOT[n+3].  */
 229
 230 /* The constants below were determined by examining the following files
 231    in the linux kernel sources:
 232
 233       arch/arm/kernel/signal.c
 234           - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
 235       include/asm-arm/unistd.h
 236           - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
 237
 238 #define ARM_LINUX_SIGRETURN_INSTR       0xef900077
 239 #define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
 240
 241 /* For ARM EABI, the syscall number is not in the SWI instruction
 242    (instead it is loaded into r7).  We recognize the pattern that
 243    glibc uses...  alternatively, we could arrange to do this by
 244    function name, but they are not always exported.  */
 245 #define ARM_SET_R7_SIGRETURN            0xe3a07077
 246 #define ARM_SET_R7_RT_SIGRETURN         0xe3a070ad
 247 #define ARM_EABI_SYSCALL                0xef000000
 248
 249 /* OABI syscall restart trampoline, used for EABI executables too
 250    whenever OABI support has been enabled in the kernel.  */
 251 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
 252 #define ARM_LDR_PC_SP_12                0xe49df00c
 253 #define ARM_LDR_PC_SP_4                 0xe49df004
 254
 255 static void
 256 arm_linux_sigtramp_cache (struct frame_info *this_frame,
 257                           struct trad_frame_cache *this_cache,
 258                           CORE_ADDR func, int regs_offset)
 259 {
 260   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 261   CORE_ADDR base = sp + regs_offset;
 262   int i;
 263
 264   for (i = 0; i < 16; i++)
 265     trad_frame_set_reg_addr (this_cache, i, base + i * 4);
 266
 267   trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
 268
 269   /* The VFP or iWMMXt registers may be saved on the stack, but there's
 270      no reliable way to restore them (yet).  */
 271
 272   /* Save a frame ID.  */
 273   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 274 }
 275
 276 /* There are a couple of different possible stack layouts that
 277    we need to support.
 278
 279    Before version 2.6.18, the kernel used completely independent
 280    layouts for non-RT and RT signals.  For non-RT signals the stack
 281    began directly with a struct sigcontext.  For RT signals the stack
 282    began with two redundant pointers (to the siginfo and ucontext),
 283    and then the siginfo and ucontext.
 284
 285    As of version 2.6.18, the non-RT signal frame layout starts with
 286    a ucontext and the RT signal frame starts with a siginfo and then
 287    a ucontext.  Also, the ucontext now has a designated save area
 288    for coprocessor registers.
 289
 290    For RT signals, it's easy to tell the difference: we look for
 291    pinfo, the pointer to the siginfo.  If it has the expected
 292    value, we have an old layout.  If it doesn't, we have the new
 293    layout.
 294
 295    For non-RT signals, it's a bit harder.  We need something in one
 296    layout or the other with a recognizable offset and value.  We can't
 297    use the return trampoline, because ARM usually uses SA_RESTORER,
 298    in which case the stack return trampoline is not filled in.
 299    We can't use the saved stack pointer, because sigaltstack might
 300    be in use.  So for now we guess the new layout...  */
 301
 302 /* There are three words (trap_no, error_code, oldmask) in
 303    struct sigcontext before r0.  */
 304 #define ARM_SIGCONTEXT_R0 0xc
 305
 306 /* There are five words (uc_flags, uc_link, and three for uc_stack)
 307    in the ucontext_t before the sigcontext.  */
 308 #define ARM_UCONTEXT_SIGCONTEXT 0x14
 309
 310 /* There are three elements in an rt_sigframe before the ucontext:
 311    pinfo, puc, and info.  The first two are pointers and the third
 312    is a struct siginfo, with size 128 bytes.  We could follow puc
 313    to the ucontext, but it's simpler to skip the whole thing.  */
 314 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
 315 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
 316
 317 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
 318
 319 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
 320
 321 static void
 322 arm_linux_sigreturn_init (const struct tramp_frame *self,
 323                           struct frame_info *this_frame,
 324                           struct trad_frame_cache *this_cache,
 325                           CORE_ADDR func)
 326 {
 327   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 328   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 329   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 330   ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
 331
 332   if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
 333     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 334                               ARM_UCONTEXT_SIGCONTEXT
 335                               + ARM_SIGCONTEXT_R0);
 336   else
 337     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 338                               ARM_SIGCONTEXT_R0);
 339 }
 340
 341 static void
 342 arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
 343                           struct frame_info *this_frame,
 344                           struct trad_frame_cache *this_cache,
 345                           CORE_ADDR func)
 346 {
 347   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 348   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 349   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 350   ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
 351
 352   if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
 353     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 354                               ARM_OLD_RT_SIGFRAME_UCONTEXT
 355                               + ARM_UCONTEXT_SIGCONTEXT
 356                               + ARM_SIGCONTEXT_R0);
 357   else
 358     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 359                               ARM_NEW_RT_SIGFRAME_UCONTEXT
 360                               + ARM_UCONTEXT_SIGCONTEXT
 361                               + ARM_SIGCONTEXT_R0);
 362 }
 363
 364 static void
 365 arm_linux_restart_syscall_init (const struct tramp_frame *self,
 366                                 struct frame_info *this_frame,
 367                                 struct trad_frame_cache *this_cache,
 368                                 CORE_ADDR func)
 369 {
 370   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 371   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 372   CORE_ADDR pc = get_frame_memory_unsigned (this_frame, sp, 4);
 373   CORE_ADDR cpsr = get_frame_register_unsigned (this_frame, ARM_PS_REGNUM);
 374   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
 375   int sp_offset;
 376
 377   /* There are two variants of this trampoline; with older kernels, the
 378      stub is placed on the stack, while newer kernels use the stub from
 379      the vector page.  They are identical except that the older version
 380      increments SP by 12 (to skip stored PC and the stub itself), while
 381      the newer version increments SP only by 4 (just the stored PC).  */
 382   if (self->insn[1].bytes == ARM_LDR_PC_SP_4)
 383     sp_offset = 4;
 384   else
 385     sp_offset = 12;
 386
 387   /* Update Thumb bit in CPSR.  */
 388   if (pc & 1)
 389     cpsr |= t_bit;
 390   else
 391     cpsr &= ~t_bit;
 392
 393   /* Remove Thumb bit from PC.  */
 394   pc = gdbarch_addr_bits_remove (gdbarch, pc);
 395
 396   /* Save previous register values.  */
 397   trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + sp_offset);
 398   trad_frame_set_reg_value (this_cache, ARM_PC_REGNUM, pc);
 399   trad_frame_set_reg_value (this_cache, ARM_PS_REGNUM, cpsr);
 400
 401   /* Save a frame ID.  */
 402   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 403 }
 404
 405 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
 406   SIGTRAMP_FRAME,
 407   4,
 408   {
 409     { ARM_LINUX_SIGRETURN_INSTR, -1 },
 410     { TRAMP_SENTINEL_INSN }
 411   },
 412   arm_linux_sigreturn_init
 413 };
 414
 415 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
 416   SIGTRAMP_FRAME,
 417   4,
 418   {
 419     { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
 420     { TRAMP_SENTINEL_INSN }
 421   },
 422   arm_linux_rt_sigreturn_init
 423 };
 424
 425 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
 426   SIGTRAMP_FRAME,
 427   4,
 428   {
 429     { ARM_SET_R7_SIGRETURN, -1 },
 430     { ARM_EABI_SYSCALL, -1 },
 431     { TRAMP_SENTINEL_INSN }
 432   },
 433   arm_linux_sigreturn_init
 434 };
 435
 436 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
 437   SIGTRAMP_FRAME,
 438   4,
 439   {
 440     { ARM_SET_R7_RT_SIGRETURN, -1 },
 441     { ARM_EABI_SYSCALL, -1 },
 442     { TRAMP_SENTINEL_INSN }
 443   },
 444   arm_linux_rt_sigreturn_init
 445 };
 446
 447 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
 448   NORMAL_FRAME,
 449   4,
 450   {
 451     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
 452     { ARM_LDR_PC_SP_12, -1 },
 453     { TRAMP_SENTINEL_INSN }
 454   },
 455   arm_linux_restart_syscall_init
 456 };
 457
 458 static struct tramp_frame arm_kernel_linux_restart_syscall_tramp_frame = {
 459   NORMAL_FRAME,
 460   4,
 461   {
 462     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
 463     { ARM_LDR_PC_SP_4, -1 },
 464     { TRAMP_SENTINEL_INSN }
 465   },
 466   arm_linux_restart_syscall_init
 467 };
 468
 469 /* Core file and register set support.  */
 470
 471 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
 472
 473 void
 474 arm_linux_supply_gregset (const struct regset *regset,
 475                           struct regcache *regcache,
 476                           int regnum, const void *gregs_buf, size_t len)
 477 {
 478   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 479   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 480   const gdb_byte *gregs = gregs_buf;
 481   int regno;
 482   CORE_ADDR reg_pc;
 483   gdb_byte pc_buf[INT_REGISTER_SIZE];
 484
 485   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 486     if (regnum == -1 || regnum == regno)
 487       regcache_raw_supply (regcache, regno,
 488                            gregs + INT_REGISTER_SIZE * regno);
 489
 490   if (regnum == ARM_PS_REGNUM || regnum == -1)
 491     {
 492       if (arm_apcs_32)
 493         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 494                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 495       else
 496         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 497                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 498     }
 499
 500   if (regnum == ARM_PC_REGNUM || regnum == -1)
 501     {
 502       reg_pc = extract_unsigned_integer (gregs
 503                                          + INT_REGISTER_SIZE * ARM_PC_REGNUM,
 504                                          INT_REGISTER_SIZE, byte_order);
 505       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
 506       store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
 507       regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
 508     }
 509 }
 510
 511 void
 512 arm_linux_collect_gregset (const struct regset *regset,
 513                            const struct regcache *regcache,
 514                            int regnum, void *gregs_buf, size_t len)
 515 {
 516   gdb_byte *gregs = gregs_buf;
 517   int regno;
 518
 519   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 520     if (regnum == -1 || regnum == regno)
 521       regcache_raw_collect (regcache, regno,
 522                             gregs + INT_REGISTER_SIZE * regno);
 523
 524   if (regnum == ARM_PS_REGNUM || regnum == -1)
 525     {
 526       if (arm_apcs_32)
 527         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 528                               gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 529       else
 530         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 531                               gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 532     }
 533
 534   if (regnum == ARM_PC_REGNUM || regnum == -1)
 535     regcache_raw_collect (regcache, ARM_PC_REGNUM,
 536                           gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 537 }
 538
 539 /* Support for register format used by the NWFPE FPA emulator.  */
 540
 541 #define typeNone                0x00
 542 #define typeSingle              0x01
 543 #define typeDouble              0x02
 544 #define typeExtended            0x03
 545
 546 void
 547 supply_nwfpe_register (struct regcache *regcache, int regno,
 548                        const gdb_byte *regs)
 549 {
 550   const gdb_byte *reg_data;
 551   gdb_byte reg_tag;
 552   gdb_byte buf[FP_REGISTER_SIZE];
 553
 554   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 555   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 556   memset (buf, 0, FP_REGISTER_SIZE);
 557
 558   switch (reg_tag)
 559     {
 560     case typeSingle:
 561       memcpy (buf, reg_data, 4);
 562       break;
 563     case typeDouble:
 564       memcpy (buf, reg_data + 4, 4);
 565       memcpy (buf + 4, reg_data, 4);
 566       break;
 567     case typeExtended:
 568       /* We want sign and exponent, then least significant bits,
 569          then most significant.  NWFPE does sign, most, least.  */
 570       memcpy (buf, reg_data, 4);
 571       memcpy (buf + 4, reg_data + 8, 4);
 572       memcpy (buf + 8, reg_data + 4, 4);
 573       break;
 574     default:
 575       break;
 576     }
 577
 578   regcache_raw_supply (regcache, regno, buf);
 579 }
 580
 581 void
 582 collect_nwfpe_register (const struct regcache *regcache, int regno,
 583                         gdb_byte *regs)
 584 {
 585   gdb_byte *reg_data;
 586   gdb_byte reg_tag;
 587   gdb_byte buf[FP_REGISTER_SIZE];
 588
 589   regcache_raw_collect (regcache, regno, buf);
 590
 591   /* NOTE drow/2006-06-07: This code uses the tag already in the
 592      register buffer.  I've preserved that when moving the code
 593      from the native file to the target file.  But this doesn't
 594      always make sense.  */
 595
 596   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 597   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 598
 599   switch (reg_tag)
 600     {
 601     case typeSingle:
 602       memcpy (reg_data, buf, 4);
 603       break;
 604     case typeDouble:
 605       memcpy (reg_data, buf + 4, 4);
 606       memcpy (reg_data + 4, buf, 4);
 607       break;
 608     case typeExtended:
 609       memcpy (reg_data, buf, 4);
 610       memcpy (reg_data + 4, buf + 8, 4);
 611       memcpy (reg_data + 8, buf + 4, 4);
 612       break;
 613     default:
 614       break;
 615     }
 616 }
 617
 618 void
 619 arm_linux_supply_nwfpe (const struct regset *regset,
 620                         struct regcache *regcache,
 621                         int regnum, const void *regs_buf, size_t len)
 622 {
 623   const gdb_byte *regs = regs_buf;
 624   int regno;
 625
 626   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 627     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 628                          regs + NWFPE_FPSR_OFFSET);
 629
 630   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 631     if (regnum == -1 || regnum == regno)
 632       supply_nwfpe_register (regcache, regno, regs);
 633 }
 634
 635 void
 636 arm_linux_collect_nwfpe (const struct regset *regset,
 637                          const struct regcache *regcache,
 638                          int regnum, void *regs_buf, size_t len)
 639 {
 640   gdb_byte *regs = regs_buf;
 641   int regno;
 642
 643   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 644     if (regnum == -1 || regnum == regno)
 645       collect_nwfpe_register (regcache, regno, regs);
 646
 647   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 648     regcache_raw_collect (regcache, ARM_FPS_REGNUM,
 649                           regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
 650 }
 651
 652 /* Support VFP register format.  */
 653
 654 #define ARM_LINUX_SIZEOF_VFP (32 * 8 + 4)
 655
 656 static void
 657 arm_linux_supply_vfp (const struct regset *regset,
 658                       struct regcache *regcache,
 659                       int regnum, const void *regs_buf, size_t len)
 660 {
 661   const gdb_byte *regs = regs_buf;
 662   int regno;
 663
 664   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
 665     regcache_raw_supply (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
 666
 667   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
 668     if (regnum == -1 || regnum == regno)
 669       regcache_raw_supply (regcache, regno,
 670                            regs + (regno - ARM_D0_REGNUM) * 8);
 671 }
 672
 673 static void
 674 arm_linux_collect_vfp (const struct regset *regset,
 675                          const struct regcache *regcache,
 676                          int regnum, void *regs_buf, size_t len)
 677 {
 678   gdb_byte *regs = regs_buf;
 679   int regno;
 680
 681   if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
 682     regcache_raw_collect (regcache, ARM_FPSCR_REGNUM, regs + 32 * 8);
 683
 684   for (regno = ARM_D0_REGNUM; regno <= ARM_D31_REGNUM; regno++)
 685     if (regnum == -1 || regnum == regno)
 686       regcache_raw_collect (regcache, regno,
 687                             regs + (regno - ARM_D0_REGNUM) * 8);
 688 }
 689
 690 static const struct regset arm_linux_gregset =
 691   {
 692     NULL, arm_linux_supply_gregset, arm_linux_collect_gregset
 693   };
 694
 695 static const struct regset arm_linux_fpregset =
 696   {
 697     NULL, arm_linux_supply_nwfpe, arm_linux_collect_nwfpe
 698   };
 699
 700 static const struct regset arm_linux_vfpregset =
 701   {
 702     NULL, arm_linux_supply_vfp, arm_linux_collect_vfp
 703   };
 704
 705 /* Return the appropriate register set for the core section identified
 706    by SECT_NAME and SECT_SIZE.  */
 707
 708 static const struct regset *
 709 arm_linux_regset_from_core_section (struct gdbarch *gdbarch,
 710                                     const char *sect_name, size_t sect_size)
 711 {
 712   if (strcmp (sect_name, ".reg") == 0
 713       && sect_size == ARM_LINUX_SIZEOF_GREGSET)
 714     return &arm_linux_gregset;
 715
 716   if (strcmp (sect_name, ".reg2") == 0
 717       && sect_size == ARM_LINUX_SIZEOF_NWFPE)
 718     return &arm_linux_fpregset;
 719
 720   if (strcmp (sect_name, ".reg-arm-vfp") == 0
 721       && sect_size == ARM_LINUX_SIZEOF_VFP)
 722     return &arm_linux_vfpregset;
 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 /* At a ptrace syscall-stop, return the syscall number.  This either
 798    comes from the SWI instruction (OABI) or from r7 (EABI).
 799
 800    When the function fails, it should return -1.  */
 801
 802 static LONGEST
 803 arm_linux_get_syscall_number (struct gdbarch *gdbarch,
 804                               ptid_t ptid)
 805 {
 806   struct regcache *regs = get_thread_regcache (ptid);
 807   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 808
 809   ULONGEST pc;
 810   ULONGEST cpsr;
 811   ULONGEST t_bit = arm_psr_thumb_bit (gdbarch);
 812   int is_thumb;
 813   ULONGEST svc_number = -1;
 814
 815   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &pc);
 816   regcache_cooked_read_unsigned (regs, ARM_PS_REGNUM, &cpsr);
 817   is_thumb = (cpsr & t_bit) != 0;
 818
 819   if (is_thumb)
 820     {
 821       regcache_cooked_read_unsigned (regs, 7, &svc_number);
 822     }
 823   else
 824     {
 825       enum bfd_endian byte_order_for_code =
 826         gdbarch_byte_order_for_code (gdbarch);
 827
 828       /* PC gets incremented before the syscall-stop, so read the
 829          previous instruction.  */
 830       unsigned long this_instr =
 831         read_memory_unsigned_integer (pc - 4, 4, byte_order_for_code);
 832
 833       unsigned long svc_operand = (0x00ffffff & this_instr);
 834
 835       if (svc_operand)
 836         {
 837           /* OABI */
 838           svc_number = svc_operand - 0x900000;
 839         }
 840       else
 841         {
 842           /* EABI */
 843           regcache_cooked_read_unsigned (regs, 7, &svc_number);
 844         }
 845     }
 846
 847   return svc_number;
 848 }
 849
 850 /* When FRAME is at a syscall instruction, return the PC of the next
 851    instruction to be executed.  */
 852
 853 static CORE_ADDR
 854 arm_linux_syscall_next_pc (struct frame_info *frame)
 855 {
 856   CORE_ADDR pc = get_frame_pc (frame);
 857   CORE_ADDR return_addr = 0;
 858   int is_thumb = arm_frame_is_thumb (frame);
 859   ULONGEST svc_number = 0;
 860
 861   if (is_thumb)
 862     {
 863       svc_number = get_frame_register_unsigned (frame, 7);
 864       return_addr = pc + 2;
 865     }
 866   else
 867     {
 868       struct gdbarch *gdbarch = get_frame_arch (frame);
 869       enum bfd_endian byte_order_for_code =
 870         gdbarch_byte_order_for_code (gdbarch);
 871       unsigned long this_instr =
 872         read_memory_unsigned_integer (pc, 4, byte_order_for_code);
 873
 874       unsigned long svc_operand = (0x00ffffff & this_instr);
 875       if (svc_operand)  /* OABI.  */
 876         {
 877           svc_number = svc_operand - 0x900000;
 878         }
 879       else /* EABI.  */
 880         {
 881           svc_number = get_frame_register_unsigned (frame, 7);
 882         }
 883
 884       return_addr = pc + 4;
 885     }
 886
 887   arm_linux_sigreturn_return_addr (frame, svc_number, &return_addr, &is_thumb);
 888
 889   /* Addresses for calling Thumb functions have the bit 0 set.  */
 890   if (is_thumb)
 891     return_addr |= 1;
 892
 893   return return_addr;
 894 }
 895
 896
 897 /* Insert a single step breakpoint at the next executed instruction.  */
 898
 899 static int
 900 arm_linux_software_single_step (struct frame_info *frame)
 901 {
 902   struct gdbarch *gdbarch = get_frame_arch (frame);
 903   struct address_space *aspace = get_frame_address_space (frame);
 904   CORE_ADDR next_pc;
 905
 906   if (arm_deal_with_atomic_sequence (frame))
 907     return 1;
 908
 909   next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
 910
 911   /* The Linux kernel offers some user-mode helpers in a high page.  We can
 912      not read this page (as of 2.6.23), and even if we could then we couldn't
 913      set breakpoints in it, and even if we could then the atomic operations
 914      would fail when interrupted.  They are all called as functions and return
 915      to the address in LR, so step to there instead.  */
 916   if (next_pc > 0xffff0000)
 917     next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
 918
 919   arm_insert_single_step_breakpoint (gdbarch, aspace, next_pc);
 920
 921   return 1;
 922 }
 923
 924 /* Support for displaced stepping of Linux SVC instructions.  */
 925
 926 static void
 927 arm_linux_cleanup_svc (struct gdbarch *gdbarch,
 928                        struct regcache *regs,
 929                        struct displaced_step_closure *dsc)
 930 {
 931   CORE_ADDR from = dsc->insn_addr;
 932   ULONGEST apparent_pc;
 933   int within_scratch;
 934
 935   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
 936
 937   within_scratch = (apparent_pc >= dsc->scratch_base
 938                     && apparent_pc < (dsc->scratch_base
 939                                       + DISPLACED_MODIFIED_INSNS * 4 + 4));
 940
 941   if (debug_displaced)
 942     {
 943       fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
 944                           "SVC step ", (unsigned long) apparent_pc);
 945       if (within_scratch)
 946         fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
 947       else
 948         fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
 949     }
 950
 951   if (within_scratch)
 952     displaced_write_reg (regs, dsc, ARM_PC_REGNUM, from + 4, BRANCH_WRITE_PC);
 953 }
 954
 955 static int
 956 arm_linux_copy_svc (struct gdbarch *gdbarch, struct regcache *regs,
 957                     struct displaced_step_closure *dsc)
 958 {
 959   CORE_ADDR return_to = 0;
 960
 961   struct frame_info *frame;
 962   unsigned int svc_number = displaced_read_reg (regs, dsc, 7);
 963   int is_sigreturn = 0;
 964   int is_thumb;
 965
 966   frame = get_current_frame ();
 967
 968   is_sigreturn = arm_linux_sigreturn_return_addr(frame, svc_number,
 969                                                  &return_to, &is_thumb);
 970   if (is_sigreturn)
 971     {
 972           struct symtab_and_line sal;
 973
 974           if (debug_displaced)
 975             fprintf_unfiltered (gdb_stdlog, "displaced: found "
 976               "sigreturn/rt_sigreturn SVC call.  PC in frame = %lx\n",
 977               (unsigned long) get_frame_pc (frame));
 978
 979           if (debug_displaced)
 980             fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx.  "
 981               "Setting momentary breakpoint.\n", (unsigned long) return_to);
 982
 983           gdb_assert (inferior_thread ()->control.step_resume_breakpoint
 984                       == NULL);
 985
 986           sal = find_pc_line (return_to, 0);
 987           sal.pc = return_to;
 988           sal.section = find_pc_overlay (return_to);
 989           sal.explicit_pc = 1;
 990
 991           frame = get_prev_frame (frame);
 992
 993           if (frame)
 994             {
 995               inferior_thread ()->control.step_resume_breakpoint
 996                 = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
 997                                             bp_step_resume);
 998
 999               /* set_momentary_breakpoint invalidates FRAME.  */
1000               frame = NULL;
1001
1002               /* We need to make sure we actually insert the momentary
1003                  breakpoint set above.  */
1004               insert_breakpoints ();
1005             }
1006           else if (debug_displaced)
1007             fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
1008                                 "frame to set momentary breakpoint for "
1009                                 "sigreturn/rt_sigreturn\n");
1010         }
1011       else if (debug_displaced)
1012         fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
1013                             "SVC call not in signal trampoline frame\n");
1014
1015
1016   /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
1017                   location, else nothing.
1018      Insn: unmodified svc.
1019      Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
1020               else leave pc alone.  */
1021
1022
1023   dsc->cleanup = &arm_linux_cleanup_svc;
1024   /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
1025      instruction.  */
1026   dsc->wrote_to_pc = 1;
1027
1028   return 0;
1029 }
1030
1031
1032 /* The following two functions implement single-stepping over calls to Linux
1033    kernel helper routines, which perform e.g. atomic operations on architecture
1034    variants which don't support them natively.
1035
1036    When this function is called, the PC will be pointing at the kernel helper
1037    (at an address inaccessible to GDB), and r14 will point to the return
1038    address.  Displaced stepping always executes code in the copy area:
1039    so, make the copy-area instruction branch back to the kernel helper (the
1040    "from" address), and make r14 point to the breakpoint in the copy area.  In
1041    that way, we regain control once the kernel helper returns, and can clean
1042    up appropriately (as if we had just returned from the kernel helper as it
1043    would have been called from the non-displaced location).  */
1044
1045 static void
1046 cleanup_kernel_helper_return (struct gdbarch *gdbarch,
1047                               struct regcache *regs,
1048                               struct displaced_step_closure *dsc)
1049 {
1050   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
1051   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
1052 }
1053
1054 static void
1055 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
1056                                 CORE_ADDR to, struct regcache *regs,
1057                                 struct displaced_step_closure *dsc)
1058 {
1059   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1060
1061   dsc->numinsns = 1;
1062   dsc->insn_addr = from;
1063   dsc->cleanup = &cleanup_kernel_helper_return;
1064   /* Say we wrote to the PC, else cleanup will set PC to the next
1065      instruction in the helper, which isn't helpful.  */
1066   dsc->wrote_to_pc = 1;
1067
1068   /* Preparation: tmp[0] <- r14
1069                   r14 <- <scratch space>+4
1070                   *(<scratch space>+8) <- from
1071      Insn: ldr pc, [r14, #4]
1072      Cleanup: r14 <- tmp[0], pc <- tmp[0].  */
1073
1074   dsc->tmp[0] = displaced_read_reg (regs, dsc, ARM_LR_REGNUM);
1075   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
1076                        CANNOT_WRITE_PC);
1077   write_memory_unsigned_integer (to + 8, 4, byte_order, from);
1078
1079   dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
1080 }
1081
1082 /* Linux-specific displaced step instruction copying function.  Detects when
1083    the program has stepped into a Linux kernel helper routine (which must be
1084    handled as a special case), falling back to arm_displaced_step_copy_insn()
1085    if it hasn't.  */
1086
1087 static struct displaced_step_closure *
1088 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
1089                                     CORE_ADDR from, CORE_ADDR to,
1090                                     struct regcache *regs)
1091 {
1092   struct displaced_step_closure *dsc
1093     = xmalloc (sizeof (struct displaced_step_closure));
1094
1095   /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
1096      stop at the return location.  */
1097   if (from > 0xffff0000)
1098     {
1099       if (debug_displaced)
1100         fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
1101                             "at %.8lx\n", (unsigned long) from);
1102
1103       arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
1104     }
1105   else
1106     {
1107       /* Override the default handling of SVC instructions.  */
1108       dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
1109
1110       arm_process_displaced_insn (gdbarch, from, to, regs, dsc);
1111     }
1112
1113   arm_displaced_init_closure (gdbarch, from, to, dsc);
1114
1115   return dsc;
1116 }
1117
1118 /* Implementation of `gdbarch_stap_is_single_operand', as defined in
1119    gdbarch.h.  */
1120
1121 static int
1122 arm_stap_is_single_operand (struct gdbarch *gdbarch, const char *s)
1123 {
1124   return (*s == '#' || *s == '$' || isdigit (*s) /* Literal number.  */
1125           || *s == '[' /* Register indirection or
1126                           displacement.  */
1127           || isalpha (*s)); /* Register value.  */
1128 }
1129
1130 /* This routine is used to parse a special token in ARM's assembly.
1131
1132    The special tokens parsed by it are:
1133
1134       - Register displacement (e.g, [fp, #-8])
1135
1136    It returns one if the special token has been parsed successfully,
1137    or zero if the current token is not considered special.  */
1138
1139 static int
1140 arm_stap_parse_special_token (struct gdbarch *gdbarch,
1141                               struct stap_parse_info *p)
1142 {
1143   if (*p->arg == '[')
1144     {
1145       /* Temporary holder for lookahead.  */
1146       const char *tmp = p->arg;
1147       char *endp;
1148       /* Used to save the register name.  */
1149       const char *start;
1150       char *regname;
1151       int len, offset;
1152       int got_minus = 0;
1153       long displacement;
1154       struct stoken str;
1155
1156       ++tmp;
1157       start = tmp;
1158
1159       /* Register name.  */
1160       while (isalnum (*tmp))
1161         ++tmp;
1162
1163       if (*tmp != ',')
1164         return 0;
1165
1166       len = tmp - start;
1167       regname = alloca (len + 2);
1168
1169       offset = 0;
1170       if (isdigit (*start))
1171         {
1172           /* If we are dealing with a register whose name begins with a
1173              digit, it means we should prefix the name with the letter
1174              `r', because GDB expects this name pattern.  Otherwise (e.g.,
1175              we are dealing with the register `fp'), we don't need to
1176              add such a prefix.  */
1177           regname[0] = 'r';
1178           offset = 1;
1179         }
1180
1181       strncpy (regname + offset, start, len);
1182       len += offset;
1183       regname[len] = '\0';
1184
1185       if (user_reg_map_name_to_regnum (gdbarch, regname, len) == -1)
1186         error (_("Invalid register name `%s' on expression `%s'."),
1187                regname, p->saved_arg);
1188
1189       ++tmp;
1190       tmp = skip_spaces_const (tmp);
1191       if (*tmp == '#' || *tmp == '$')
1192         ++tmp;
1193
1194       if (*tmp == '-')
1195         {
1196           ++tmp;
1197           got_minus = 1;
1198         }
1199
1200       displacement = strtol (tmp, &endp, 10);
1201       tmp = endp;
1202
1203       /* Skipping last `]'.  */
1204       if (*tmp++ != ']')
1205         return 0;
1206
1207       /* The displacement.  */
1208       write_exp_elt_opcode (&p->pstate, OP_LONG);
1209       write_exp_elt_type (&p->pstate, builtin_type (gdbarch)->builtin_long);
1210       write_exp_elt_longcst (&p->pstate, displacement);
1211       write_exp_elt_opcode (&p->pstate, OP_LONG);
1212       if (got_minus)
1213         write_exp_elt_opcode (&p->pstate, UNOP_NEG);
1214
1215       /* The register name.  */
1216       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1217       str.ptr = regname;
1218       str.length = len;
1219       write_exp_string (&p->pstate, str);
1220       write_exp_elt_opcode (&p->pstate, OP_REGISTER);
1221
1222       write_exp_elt_opcode (&p->pstate, BINOP_ADD);
1223
1224       /* Casting to the expected type.  */
1225       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1226       write_exp_elt_type (&p->pstate, lookup_pointer_type (p->arg_type));
1227       write_exp_elt_opcode (&p->pstate, UNOP_CAST);
1228
1229       write_exp_elt_opcode (&p->pstate, UNOP_IND);
1230
1231       p->arg = tmp;
1232     }
1233   else
1234     return 0;
1235
1236   return 1;
1237 }
1238
1239 /* ARM process record-replay constructs: syscall, signal etc.  */
1240
1241 struct linux_record_tdep arm_linux_record_tdep;
1242
1243 /* arm_canonicalize_syscall maps from the native arm Linux set
1244    of syscall ids into a canonical set of syscall ids used by
1245    process record.  */
1246
1247 static enum gdb_syscall
1248 arm_canonicalize_syscall (int syscall)
1249 {
1250   enum { sys_process_vm_writev = 377 };
1251
1252   if (syscall <= gdb_sys_sched_getaffinity)
1253     return syscall;
1254   else if (syscall >= 243 && syscall <= 247)
1255     return syscall + 2;
1256   else if (syscall >= 248 && syscall <= 253)
1257     return syscall + 4;
1258
1259   return -1;
1260 }
1261
1262 /* Record all registers but PC register for process-record.  */
1263
1264 static int
1265 arm_all_but_pc_registers_record (struct regcache *regcache)
1266 {
1267   int i;
1268
1269   for (i = 0; i < ARM_PC_REGNUM; i++)
1270     {
1271       if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM + i))
1272         return -1;
1273     }
1274
1275   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1276     return -1;
1277
1278   return 0;
1279 }
1280
1281 /* Handler for arm system call instruction recording.  */
1282
1283 static int
1284 arm_linux_syscall_record (struct regcache *regcache, unsigned long svc_number)
1285 {
1286   int ret = 0;
1287   enum gdb_syscall syscall_gdb;
1288
1289   syscall_gdb = arm_canonicalize_syscall (svc_number);
1290
1291   if (syscall_gdb < 0)
1292     {
1293       printf_unfiltered (_("Process record and replay target doesn't "
1294                            "support syscall number %s\n"),
1295                            plongest (svc_number));
1296       return -1;
1297     }
1298
1299   if (syscall_gdb == gdb_sys_sigreturn
1300       || syscall_gdb == gdb_sys_rt_sigreturn)
1301    {
1302      if (arm_all_but_pc_registers_record (regcache))
1303        return -1;
1304      return 0;
1305    }
1306
1307   ret = record_linux_system_call (syscall_gdb, regcache,
1308                                   &arm_linux_record_tdep);
1309   if (ret != 0)
1310     return ret;
1311
1312   /* Record the return value of the system call.  */
1313   if (record_full_arch_list_add_reg (regcache, ARM_A1_REGNUM))
1314     return -1;
1315   /* Record LR.  */
1316   if (record_full_arch_list_add_reg (regcache, ARM_LR_REGNUM))
1317     return -1;
1318   /* Record CPSR.  */
1319   if (record_full_arch_list_add_reg (regcache, ARM_PS_REGNUM))
1320     return -1;
1321
1322   return 0;
1323 }
1324
1325 /* Implement the skip_trampoline_code gdbarch method.  */
1326
1327 static CORE_ADDR
1328 arm_linux_skip_trampoline_code (struct frame_info *frame, CORE_ADDR pc)
1329 {
1330   CORE_ADDR target_pc = arm_skip_stub (frame, pc);
1331
1332   if (target_pc != 0)
1333     return target_pc;
1334
1335   return find_solib_trampoline_target (frame, pc);
1336 }
1337
1338 static void
1339 arm_linux_init_abi (struct gdbarch_info info,
1340                     struct gdbarch *gdbarch)
1341 {
1342   static const char *const stap_integer_prefixes[] = { "#", "$", "", NULL };
1343   static const char *const stap_register_prefixes[] = { "r", NULL };
1344   static const char *const stap_register_indirection_prefixes[] = { "[",
1345                                                                     NULL };
1346   static const char *const stap_register_indirection_suffixes[] = { "]",
1347                                                                     NULL };
1348   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1349
1350   linux_init_abi (info, gdbarch);
1351
1352   tdep->lowest_pc = 0x8000;
1353   if (info.byte_order == BFD_ENDIAN_BIG)
1354     {
1355       if (tdep->arm_abi == ARM_ABI_AAPCS)
1356         tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
1357       else
1358         tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
1359       tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
1360       tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
1361     }
1362   else
1363     {
1364       if (tdep->arm_abi == ARM_ABI_AAPCS)
1365         tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
1366       else
1367         tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
1368       tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
1369       tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
1370     }
1371   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
1372   tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
1373   tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);
1374
1375   if (tdep->fp_model == ARM_FLOAT_AUTO)
1376     tdep->fp_model = ARM_FLOAT_FPA;
1377
1378   switch (tdep->fp_model)
1379     {
1380     case ARM_FLOAT_FPA:
1381       tdep->jb_pc = ARM_LINUX_JB_PC_FPA;
1382       break;
1383     case ARM_FLOAT_SOFT_FPA:
1384     case ARM_FLOAT_SOFT_VFP:
1385     case ARM_FLOAT_VFP:
1386       tdep->jb_pc = ARM_LINUX_JB_PC_EABI;
1387       break;
1388     default:
1389       internal_error
1390         (__FILE__, __LINE__,
1391          _("arm_linux_init_abi: Floating point model not supported"));
1392       break;
1393     }
1394   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
1395
1396   set_solib_svr4_fetch_link_map_offsets
1397     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
1398
1399   /* Single stepping.  */
1400   set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
1401
1402   /* Shared library handling.  */
1403   set_gdbarch_skip_trampoline_code (gdbarch, arm_linux_skip_trampoline_code);
1404   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
1405
1406   /* Enable TLS support.  */
1407   set_gdbarch_fetch_tls_load_module_address (gdbarch,
1408                                              svr4_fetch_objfile_link_map);
1409
1410   tramp_frame_prepend_unwinder (gdbarch,
1411                                 &arm_linux_sigreturn_tramp_frame);
1412   tramp_frame_prepend_unwinder (gdbarch,
1413                                 &arm_linux_rt_sigreturn_tramp_frame);
1414   tramp_frame_prepend_unwinder (gdbarch,
1415                                 &arm_eabi_linux_sigreturn_tramp_frame);
1416   tramp_frame_prepend_unwinder (gdbarch,
1417                                 &arm_eabi_linux_rt_sigreturn_tramp_frame);
1418   tramp_frame_prepend_unwinder (gdbarch,
1419                                 &arm_linux_restart_syscall_tramp_frame);
1420   tramp_frame_prepend_unwinder (gdbarch,
1421                                 &arm_kernel_linux_restart_syscall_tramp_frame);
1422
1423   /* Core file support.  */
1424   set_gdbarch_regset_from_core_section (gdbarch,
1425                                         arm_linux_regset_from_core_section);
1426   set_gdbarch_core_read_description (gdbarch, arm_linux_core_read_description);
1427
1428   if (tdep->have_vfp_registers)
1429     set_gdbarch_core_regset_sections (gdbarch, arm_linux_vfp_regset_sections);
1430   else if (tdep->have_fpa_registers)
1431     set_gdbarch_core_regset_sections (gdbarch, arm_linux_fpa_regset_sections);
1432
1433   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
1434
1435   /* Displaced stepping.  */
1436   set_gdbarch_displaced_step_copy_insn (gdbarch,
1437                                         arm_linux_displaced_step_copy_insn);
1438   set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
1439   set_gdbarch_displaced_step_free_closure (gdbarch,
1440                                            simple_displaced_step_free_closure);
1441   set_gdbarch_displaced_step_location (gdbarch, displaced_step_at_entry_point);
1442
1443   /* Reversible debugging, process record.  */
1444   set_gdbarch_process_record (gdbarch, arm_process_record);
1445
1446   /* SystemTap functions.  */
1447   set_gdbarch_stap_integer_prefixes (gdbarch, stap_integer_prefixes);
1448   set_gdbarch_stap_register_prefixes (gdbarch, stap_register_prefixes);
1449   set_gdbarch_stap_register_indirection_prefixes (gdbarch,
1450                                           stap_register_indirection_prefixes);
1451   set_gdbarch_stap_register_indirection_suffixes (gdbarch,
1452                                           stap_register_indirection_suffixes);
1453   set_gdbarch_stap_gdb_register_prefix (gdbarch, "r");
1454   set_gdbarch_stap_is_single_operand (gdbarch, arm_stap_is_single_operand);
1455   set_gdbarch_stap_parse_special_token (gdbarch,
1456                                         arm_stap_parse_special_token);
1457
1458   tdep->syscall_next_pc = arm_linux_syscall_next_pc;
1459
1460   /* `catch syscall' */
1461   set_xml_syscall_file_name ("syscalls/arm-linux.xml");
1462   set_gdbarch_get_syscall_number (gdbarch, arm_linux_get_syscall_number);
1463
1464   /* Syscall record.  */
1465   tdep->arm_syscall_record = arm_linux_syscall_record;
1466
1467   /* Initialize the arm_linux_record_tdep.  */
1468   /* These values are the size of the type that will be used in a system
1469      call.  They are obtained from Linux Kernel source.  */
1470   arm_linux_record_tdep.size_pointer
1471     = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1472   arm_linux_record_tdep.size__old_kernel_stat = 32;
1473   arm_linux_record_tdep.size_tms = 16;
1474   arm_linux_record_tdep.size_loff_t = 8;
1475   arm_linux_record_tdep.size_flock = 16;
1476   arm_linux_record_tdep.size_oldold_utsname = 45;
1477   arm_linux_record_tdep.size_ustat = 20;
1478   arm_linux_record_tdep.size_old_sigaction = 140;
1479   arm_linux_record_tdep.size_old_sigset_t = 128;
1480   arm_linux_record_tdep.size_rlimit = 8;
1481   arm_linux_record_tdep.size_rusage = 72;
1482   arm_linux_record_tdep.size_timeval = 8;
1483   arm_linux_record_tdep.size_timezone = 8;
1484   arm_linux_record_tdep.size_old_gid_t = 2;
1485   arm_linux_record_tdep.size_old_uid_t = 2;
1486   arm_linux_record_tdep.size_fd_set = 128;
1487   arm_linux_record_tdep.size_dirent = 268;
1488   arm_linux_record_tdep.size_dirent64 = 276;
1489   arm_linux_record_tdep.size_statfs = 64;
1490   arm_linux_record_tdep.size_statfs64 = 84;
1491   arm_linux_record_tdep.size_sockaddr = 16;
1492   arm_linux_record_tdep.size_int
1493     = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
1494   arm_linux_record_tdep.size_long
1495     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1496   arm_linux_record_tdep.size_ulong
1497     = gdbarch_long_bit (gdbarch) / TARGET_CHAR_BIT;
1498   arm_linux_record_tdep.size_msghdr = 28;
1499   arm_linux_record_tdep.size_itimerval = 16;
1500   arm_linux_record_tdep.size_stat = 88;
1501   arm_linux_record_tdep.size_old_utsname = 325;
1502   arm_linux_record_tdep.size_sysinfo = 64;
1503   arm_linux_record_tdep.size_msqid_ds = 88;
1504   arm_linux_record_tdep.size_shmid_ds = 84;
1505   arm_linux_record_tdep.size_new_utsname = 390;
1506   arm_linux_record_tdep.size_timex = 128;
1507   arm_linux_record_tdep.size_mem_dqinfo = 24;
1508   arm_linux_record_tdep.size_if_dqblk = 68;
1509   arm_linux_record_tdep.size_fs_quota_stat = 68;
1510   arm_linux_record_tdep.size_timespec = 8;
1511   arm_linux_record_tdep.size_pollfd = 8;
1512   arm_linux_record_tdep.size_NFS_FHSIZE = 32;
1513   arm_linux_record_tdep.size_knfsd_fh = 132;
1514   arm_linux_record_tdep.size_TASK_COMM_LEN = 16;
1515   arm_linux_record_tdep.size_sigaction = 140;
1516   arm_linux_record_tdep.size_sigset_t = 8;
1517   arm_linux_record_tdep.size_siginfo_t = 128;
1518   arm_linux_record_tdep.size_cap_user_data_t = 12;
1519   arm_linux_record_tdep.size_stack_t = 12;
1520   arm_linux_record_tdep.size_off_t = arm_linux_record_tdep.size_long;
1521   arm_linux_record_tdep.size_stat64 = 96;
1522   arm_linux_record_tdep.size_gid_t = 2;
1523   arm_linux_record_tdep.size_uid_t = 2;
1524   arm_linux_record_tdep.size_PAGE_SIZE = 4096;
1525   arm_linux_record_tdep.size_flock64 = 24;
1526   arm_linux_record_tdep.size_user_desc = 16;
1527   arm_linux_record_tdep.size_io_event = 32;
1528   arm_linux_record_tdep.size_iocb = 64;
1529   arm_linux_record_tdep.size_epoll_event = 12;
1530   arm_linux_record_tdep.size_itimerspec
1531     = arm_linux_record_tdep.size_timespec * 2;
1532   arm_linux_record_tdep.size_mq_attr = 32;
1533   arm_linux_record_tdep.size_siginfo = 128;
1534   arm_linux_record_tdep.size_termios = 36;
1535   arm_linux_record_tdep.size_termios2 = 44;
1536   arm_linux_record_tdep.size_pid_t = 4;
1537   arm_linux_record_tdep.size_winsize = 8;
1538   arm_linux_record_tdep.size_serial_struct = 60;
1539   arm_linux_record_tdep.size_serial_icounter_struct = 80;
1540   arm_linux_record_tdep.size_hayes_esp_config = 12;
1541   arm_linux_record_tdep.size_size_t = 4;
1542   arm_linux_record_tdep.size_iovec = 8;
1543
1544   /* These values are the second argument of system call "sys_ioctl".
1545      They are obtained from Linux Kernel source.  */
1546   arm_linux_record_tdep.ioctl_TCGETS = 0x5401;
1547   arm_linux_record_tdep.ioctl_TCSETS = 0x5402;
1548   arm_linux_record_tdep.ioctl_TCSETSW = 0x5403;
1549   arm_linux_record_tdep.ioctl_TCSETSF = 0x5404;
1550   arm_linux_record_tdep.ioctl_TCGETA = 0x5405;
1551   arm_linux_record_tdep.ioctl_TCSETA = 0x5406;
1552   arm_linux_record_tdep.ioctl_TCSETAW = 0x5407;
1553   arm_linux_record_tdep.ioctl_TCSETAF = 0x5408;
1554   arm_linux_record_tdep.ioctl_TCSBRK = 0x5409;
1555   arm_linux_record_tdep.ioctl_TCXONC = 0x540a;
1556   arm_linux_record_tdep.ioctl_TCFLSH = 0x540b;
1557   arm_linux_record_tdep.ioctl_TIOCEXCL = 0x540c;
1558   arm_linux_record_tdep.ioctl_TIOCNXCL = 0x540d;
1559   arm_linux_record_tdep.ioctl_TIOCSCTTY = 0x540e;
1560   arm_linux_record_tdep.ioctl_TIOCGPGRP = 0x540f;
1561   arm_linux_record_tdep.ioctl_TIOCSPGRP = 0x5410;
1562   arm_linux_record_tdep.ioctl_TIOCOUTQ = 0x5411;
1563   arm_linux_record_tdep.ioctl_TIOCSTI = 0x5412;
1564   arm_linux_record_tdep.ioctl_TIOCGWINSZ = 0x5413;
1565   arm_linux_record_tdep.ioctl_TIOCSWINSZ = 0x5414;
1566   arm_linux_record_tdep.ioctl_TIOCMGET = 0x5415;
1567   arm_linux_record_tdep.ioctl_TIOCMBIS = 0x5416;
1568   arm_linux_record_tdep.ioctl_TIOCMBIC = 0x5417;
1569   arm_linux_record_tdep.ioctl_TIOCMSET = 0x5418;
1570   arm_linux_record_tdep.ioctl_TIOCGSOFTCAR = 0x5419;
1571   arm_linux_record_tdep.ioctl_TIOCSSOFTCAR = 0x541a;
1572   arm_linux_record_tdep.ioctl_FIONREAD = 0x541b;
1573   arm_linux_record_tdep.ioctl_TIOCINQ = arm_linux_record_tdep.ioctl_FIONREAD;
1574   arm_linux_record_tdep.ioctl_TIOCLINUX = 0x541c;
1575   arm_linux_record_tdep.ioctl_TIOCCONS = 0x541d;
1576   arm_linux_record_tdep.ioctl_TIOCGSERIAL = 0x541e;
1577   arm_linux_record_tdep.ioctl_TIOCSSERIAL = 0x541f;
1578   arm_linux_record_tdep.ioctl_TIOCPKT = 0x5420;
1579   arm_linux_record_tdep.ioctl_FIONBIO = 0x5421;
1580   arm_linux_record_tdep.ioctl_TIOCNOTTY = 0x5422;
1581   arm_linux_record_tdep.ioctl_TIOCSETD = 0x5423;
1582   arm_linux_record_tdep.ioctl_TIOCGETD = 0x5424;
1583   arm_linux_record_tdep.ioctl_TCSBRKP = 0x5425;
1584   arm_linux_record_tdep.ioctl_TIOCTTYGSTRUCT = 0x5426;
1585   arm_linux_record_tdep.ioctl_TIOCSBRK = 0x5427;
1586   arm_linux_record_tdep.ioctl_TIOCCBRK = 0x5428;
1587   arm_linux_record_tdep.ioctl_TIOCGSID = 0x5429;
1588   arm_linux_record_tdep.ioctl_TCGETS2 = 0x802c542a;
1589   arm_linux_record_tdep.ioctl_TCSETS2 = 0x402c542b;
1590   arm_linux_record_tdep.ioctl_TCSETSW2 = 0x402c542c;
1591   arm_linux_record_tdep.ioctl_TCSETSF2 = 0x402c542d;
1592   arm_linux_record_tdep.ioctl_TIOCGPTN = 0x80045430;
1593   arm_linux_record_tdep.ioctl_TIOCSPTLCK = 0x40045431;
1594   arm_linux_record_tdep.ioctl_FIONCLEX = 0x5450;
1595   arm_linux_record_tdep.ioctl_FIOCLEX = 0x5451;
1596   arm_linux_record_tdep.ioctl_FIOASYNC = 0x5452;
1597   arm_linux_record_tdep.ioctl_TIOCSERCONFIG = 0x5453;
1598   arm_linux_record_tdep.ioctl_TIOCSERGWILD = 0x5454;
1599   arm_linux_record_tdep.ioctl_TIOCSERSWILD = 0x5455;
1600   arm_linux_record_tdep.ioctl_TIOCGLCKTRMIOS = 0x5456;
1601   arm_linux_record_tdep.ioctl_TIOCSLCKTRMIOS = 0x5457;
1602   arm_linux_record_tdep.ioctl_TIOCSERGSTRUCT = 0x5458;
1603   arm_linux_record_tdep.ioctl_TIOCSERGETLSR = 0x5459;
1604   arm_linux_record_tdep.ioctl_TIOCSERGETMULTI = 0x545a;
1605   arm_linux_record_tdep.ioctl_TIOCSERSETMULTI = 0x545b;
1606   arm_linux_record_tdep.ioctl_TIOCMIWAIT = 0x545c;
1607   arm_linux_record_tdep.ioctl_TIOCGICOUNT = 0x545d;
1608   arm_linux_record_tdep.ioctl_TIOCGHAYESESP = 0x545e;
1609   arm_linux_record_tdep.ioctl_TIOCSHAYESESP = 0x545f;
1610   arm_linux_record_tdep.ioctl_FIOQSIZE = 0x5460;
1611
1612   /* These values are the second argument of system call "sys_fcntl"
1613      and "sys_fcntl64".  They are obtained from Linux Kernel source.  */
1614   arm_linux_record_tdep.fcntl_F_GETLK = 5;
1615   arm_linux_record_tdep.fcntl_F_GETLK64 = 12;
1616   arm_linux_record_tdep.fcntl_F_SETLK64 = 13;
1617   arm_linux_record_tdep.fcntl_F_SETLKW64 = 14;
1618
1619   arm_linux_record_tdep.arg1 = ARM_A1_REGNUM + 1;
1620   arm_linux_record_tdep.arg2 = ARM_A1_REGNUM + 2;
1621   arm_linux_record_tdep.arg3 = ARM_A1_REGNUM + 3;
1622   arm_linux_record_tdep.arg4 = ARM_A1_REGNUM + 3;
1623 }
1624
1625 /* Provide a prototype to silence -Wmissing-prototypes.  */
1626 extern initialize_file_ftype _initialize_arm_linux_tdep;
1627
1628 void
1629 _initialize_arm_linux_tdep (void)
1630 {
1631   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
1632                           arm_linux_init_abi);
1633 }