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