gdb/arm-linux-tdep.c

   1 /* GNU/Linux on ARM target support.
   2
   3    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   4    2009 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "target.h"
  23 #include "value.h"
  24 #include "gdbtypes.h"
  25 #include "floatformat.h"
  26 #include "gdbcore.h"
  27 #include "frame.h"
  28 #include "regcache.h"
  29 #include "doublest.h"
  30 #include "solib-svr4.h"
  31 #include "osabi.h"
  32 #include "regset.h"
  33 #include "trad-frame.h"
  34 #include "tramp-frame.h"
  35 #include "breakpoint.h"
  36
  37 #include "arm-tdep.h"
  38 #include "arm-linux-tdep.h"
  39 #include "linux-tdep.h"
  40 #include "glibc-tdep.h"
  41 #include "arch-utils.h"
  42 #include "inferior.h"
  43 #include "gdbthread.h"
  44 #include "symfile.h"
  45
  46 #include "gdb_string.h"
  47
  48 extern int arm_apcs_32;
  49
  50 /* Under ARM GNU/Linux the traditional way of performing a breakpoint
  51    is to execute a particular software interrupt, rather than use a
  52    particular undefined instruction to provoke a trap.  Upon exection
  53    of the software interrupt the kernel stops the inferior with a
  54    SIGTRAP, and wakes the debugger.  */
  55
  56 static const char arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
  57
  58 static const char arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
  59
  60 /* However, the EABI syscall interface (new in Nov. 2005) does not look at
  61    the operand of the swi if old-ABI compatibility is disabled.  Therefore,
  62    use an undefined instruction instead.  This is supported as of kernel
  63    version 2.5.70 (May 2003), so should be a safe assumption for EABI
  64    binaries.  */
  65
  66 static const char eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
  67
  68 static const char eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
  69
  70 /* All the kernels which support Thumb support using a specific undefined
  71    instruction for the Thumb breakpoint.  */
  72
  73 static const char arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
  74
  75 static const char arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
  76
  77 /* Description of the longjmp buffer.  */
  78 #define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_SIZE
  79 #define ARM_LINUX_JB_PC                 21
  80
  81 /*
  82    Dynamic Linking on ARM GNU/Linux
  83    --------------------------------
  84
  85    Note: PLT = procedure linkage table
  86    GOT = global offset table
  87
  88    As much as possible, ELF dynamic linking defers the resolution of
  89    jump/call addresses until the last minute. The technique used is
  90    inspired by the i386 ELF design, and is based on the following
  91    constraints.
  92
  93    1) The calling technique should not force a change in the assembly
  94    code produced for apps; it MAY cause changes in the way assembly
  95    code is produced for position independent code (i.e. shared
  96    libraries).
  97
  98    2) The technique must be such that all executable areas must not be
  99    modified; and any modified areas must not be executed.
 100
 101    To do this, there are three steps involved in a typical jump:
 102
 103    1) in the code
 104    2) through the PLT
 105    3) using a pointer from the GOT
 106
 107    When the executable or library is first loaded, each GOT entry is
 108    initialized to point to the code which implements dynamic name
 109    resolution and code finding.  This is normally a function in the
 110    program interpreter (on ARM GNU/Linux this is usually
 111    ld-linux.so.2, but it does not have to be).  On the first
 112    invocation, the function is located and the GOT entry is replaced
 113    with the real function address.  Subsequent calls go through steps
 114    1, 2 and 3 and end up calling the real code.
 115
 116    1) In the code:
 117
 118    b    function_call
 119    bl   function_call
 120
 121    This is typical ARM code using the 26 bit relative branch or branch
 122    and link instructions.  The target of the instruction
 123    (function_call is usually the address of the function to be called.
 124    In position independent code, the target of the instruction is
 125    actually an entry in the PLT when calling functions in a shared
 126    library.  Note that this call is identical to a normal function
 127    call, only the target differs.
 128
 129    2) In the PLT:
 130
 131    The PLT is a synthetic area, created by the linker. It exists in
 132    both executables and libraries. It is an array of stubs, one per
 133    imported function call. It looks like this:
 134
 135    PLT[0]:
 136    str     lr, [sp, #-4]!       @push the return address (lr)
 137    ldr     lr, [pc, #16]   @load from 6 words ahead
 138    add     lr, pc, lr      @form an address for GOT[0]
 139    ldr     pc, [lr, #8]!   @jump to the contents of that addr
 140
 141    The return address (lr) is pushed on the stack and used for
 142    calculations.  The load on the second line loads the lr with
 143    &GOT[3] - . - 20.  The addition on the third leaves:
 144
 145    lr = (&GOT[3] - . - 20) + (. + 8)
 146    lr = (&GOT[3] - 12)
 147    lr = &GOT[0]
 148
 149    On the fourth line, the pc and lr are both updated, so that:
 150
 151    pc = GOT[2]
 152    lr = &GOT[0] + 8
 153    = &GOT[2]
 154
 155    NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
 156    "tight", but allows us to keep all the PLT entries the same size.
 157
 158    PLT[n+1]:
 159    ldr     ip, [pc, #4]    @load offset from gotoff
 160    add     ip, pc, ip      @add the offset to the pc
 161    ldr     pc, [ip]        @jump to that address
 162    gotoff: .word   GOT[n+3] - .
 163
 164    The load on the first line, gets an offset from the fourth word of
 165    the PLT entry.  The add on the second line makes ip = &GOT[n+3],
 166    which contains either a pointer to PLT[0] (the fixup trampoline) or
 167    a pointer to the actual code.
 168
 169    3) In the GOT:
 170
 171    The GOT contains helper pointers for both code (PLT) fixups and
 172    data fixups.  The first 3 entries of the GOT are special. The next
 173    M entries (where M is the number of entries in the PLT) belong to
 174    the PLT fixups. The next D (all remaining) entries belong to
 175    various data fixups. The actual size of the GOT is 3 + M + D.
 176
 177    The GOT is also a synthetic area, created by the linker. It exists
 178    in both executables and libraries.  When the GOT is first
 179    initialized , all the GOT entries relating to PLT fixups are
 180    pointing to code back at PLT[0].
 181
 182    The special entries in the GOT are:
 183
 184    GOT[0] = linked list pointer used by the dynamic loader
 185    GOT[1] = pointer to the reloc table for this module
 186    GOT[2] = pointer to the fixup/resolver code
 187
 188    The first invocation of function call comes through and uses the
 189    fixup/resolver code.  On the entry to the fixup/resolver code:
 190
 191    ip = &GOT[n+3]
 192    lr = &GOT[2]
 193    stack[0] = return address (lr) of the function call
 194    [r0, r1, r2, r3] are still the arguments to the function call
 195
 196    This is enough information for the fixup/resolver code to work
 197    with.  Before the fixup/resolver code returns, it actually calls
 198    the requested function and repairs &GOT[n+3].  */
 199
 200 /* The constants below were determined by examining the following files
 201    in the linux kernel sources:
 202
 203       arch/arm/kernel/signal.c
 204           - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
 205       include/asm-arm/unistd.h
 206           - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
 207
 208 #define ARM_LINUX_SIGRETURN_INSTR       0xef900077
 209 #define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
 210
 211 /* For ARM EABI, the syscall number is not in the SWI instruction
 212    (instead it is loaded into r7).  We recognize the pattern that
 213    glibc uses...  alternatively, we could arrange to do this by
 214    function name, but they are not always exported.  */
 215 #define ARM_SET_R7_SIGRETURN            0xe3a07077
 216 #define ARM_SET_R7_RT_SIGRETURN         0xe3a070ad
 217 #define ARM_EABI_SYSCALL                0xef000000
 218
 219 /* OABI syscall restart trampoline, used for EABI executables too
 220    whenever OABI support has been enabled in the kernel.  */
 221 #define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
 222 #define ARM_LDR_PC_SP_12                0xe49df00c
 223
 224 static void
 225 arm_linux_sigtramp_cache (struct frame_info *this_frame,
 226                           struct trad_frame_cache *this_cache,
 227                           CORE_ADDR func, int regs_offset)
 228 {
 229   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 230   CORE_ADDR base = sp + regs_offset;
 231   int i;
 232
 233   for (i = 0; i < 16; i++)
 234     trad_frame_set_reg_addr (this_cache, i, base + i * 4);
 235
 236   trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
 237
 238   /* The VFP or iWMMXt registers may be saved on the stack, but there's
 239      no reliable way to restore them (yet).  */
 240
 241   /* Save a frame ID.  */
 242   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 243 }
 244
 245 /* There are a couple of different possible stack layouts that
 246    we need to support.
 247
 248    Before version 2.6.18, the kernel used completely independent
 249    layouts for non-RT and RT signals.  For non-RT signals the stack
 250    began directly with a struct sigcontext.  For RT signals the stack
 251    began with two redundant pointers (to the siginfo and ucontext),
 252    and then the siginfo and ucontext.
 253
 254    As of version 2.6.18, the non-RT signal frame layout starts with
 255    a ucontext and the RT signal frame starts with a siginfo and then
 256    a ucontext.  Also, the ucontext now has a designated save area
 257    for coprocessor registers.
 258
 259    For RT signals, it's easy to tell the difference: we look for
 260    pinfo, the pointer to the siginfo.  If it has the expected
 261    value, we have an old layout.  If it doesn't, we have the new
 262    layout.
 263
 264    For non-RT signals, it's a bit harder.  We need something in one
 265    layout or the other with a recognizable offset and value.  We can't
 266    use the return trampoline, because ARM usually uses SA_RESTORER,
 267    in which case the stack return trampoline is not filled in.
 268    We can't use the saved stack pointer, because sigaltstack might
 269    be in use.  So for now we guess the new layout...  */
 270
 271 /* There are three words (trap_no, error_code, oldmask) in
 272    struct sigcontext before r0.  */
 273 #define ARM_SIGCONTEXT_R0 0xc
 274
 275 /* There are five words (uc_flags, uc_link, and three for uc_stack)
 276    in the ucontext_t before the sigcontext.  */
 277 #define ARM_UCONTEXT_SIGCONTEXT 0x14
 278
 279 /* There are three elements in an rt_sigframe before the ucontext:
 280    pinfo, puc, and info.  The first two are pointers and the third
 281    is a struct siginfo, with size 128 bytes.  We could follow puc
 282    to the ucontext, but it's simpler to skip the whole thing.  */
 283 #define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
 284 #define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
 285
 286 #define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
 287
 288 #define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
 289
 290 static void
 291 arm_linux_sigreturn_init (const struct tramp_frame *self,
 292                           struct frame_info *this_frame,
 293                           struct trad_frame_cache *this_cache,
 294                           CORE_ADDR func)
 295 {
 296   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 297   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 298   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 299   ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
 300
 301   if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
 302     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 303                               ARM_UCONTEXT_SIGCONTEXT
 304                               + ARM_SIGCONTEXT_R0);
 305   else
 306     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 307                               ARM_SIGCONTEXT_R0);
 308 }
 309
 310 static void
 311 arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
 312                           struct frame_info *this_frame,
 313                           struct trad_frame_cache *this_cache,
 314                           CORE_ADDR func)
 315 {
 316   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 317   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 318   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 319   ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
 320
 321   if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
 322     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 323                               ARM_OLD_RT_SIGFRAME_UCONTEXT
 324                               + ARM_UCONTEXT_SIGCONTEXT
 325                               + ARM_SIGCONTEXT_R0);
 326   else
 327     arm_linux_sigtramp_cache (this_frame, this_cache, func,
 328                               ARM_NEW_RT_SIGFRAME_UCONTEXT
 329                               + ARM_UCONTEXT_SIGCONTEXT
 330                               + ARM_SIGCONTEXT_R0);
 331 }
 332
 333 static void
 334 arm_linux_restart_syscall_init (const struct tramp_frame *self,
 335                                 struct frame_info *this_frame,
 336                                 struct trad_frame_cache *this_cache,
 337                                 CORE_ADDR func)
 338 {
 339   CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 340
 341   trad_frame_set_reg_addr (this_cache, ARM_PC_REGNUM, sp);
 342   trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + 12);
 343
 344   /* Save a frame ID.  */
 345   trad_frame_set_id (this_cache, frame_id_build (sp, func));
 346 }
 347
 348 static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
 349   SIGTRAMP_FRAME,
 350   4,
 351   {
 352     { ARM_LINUX_SIGRETURN_INSTR, -1 },
 353     { TRAMP_SENTINEL_INSN }
 354   },
 355   arm_linux_sigreturn_init
 356 };
 357
 358 static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
 359   SIGTRAMP_FRAME,
 360   4,
 361   {
 362     { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
 363     { TRAMP_SENTINEL_INSN }
 364   },
 365   arm_linux_rt_sigreturn_init
 366 };
 367
 368 static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
 369   SIGTRAMP_FRAME,
 370   4,
 371   {
 372     { ARM_SET_R7_SIGRETURN, -1 },
 373     { ARM_EABI_SYSCALL, -1 },
 374     { TRAMP_SENTINEL_INSN }
 375   },
 376   arm_linux_sigreturn_init
 377 };
 378
 379 static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
 380   SIGTRAMP_FRAME,
 381   4,
 382   {
 383     { ARM_SET_R7_RT_SIGRETURN, -1 },
 384     { ARM_EABI_SYSCALL, -1 },
 385     { TRAMP_SENTINEL_INSN }
 386   },
 387   arm_linux_rt_sigreturn_init
 388 };
 389
 390 static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
 391   NORMAL_FRAME,
 392   4,
 393   {
 394     { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
 395     { ARM_LDR_PC_SP_12, -1 },
 396     { TRAMP_SENTINEL_INSN }
 397   },
 398   arm_linux_restart_syscall_init
 399 };
 400
 401 /* Core file and register set support.  */
 402
 403 #define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
 404
 405 void
 406 arm_linux_supply_gregset (const struct regset *regset,
 407                           struct regcache *regcache,
 408                           int regnum, const void *gregs_buf, size_t len)
 409 {
 410   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 411   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 412   const gdb_byte *gregs = gregs_buf;
 413   int regno;
 414   CORE_ADDR reg_pc;
 415   gdb_byte pc_buf[INT_REGISTER_SIZE];
 416
 417   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 418     if (regnum == -1 || regnum == regno)
 419       regcache_raw_supply (regcache, regno,
 420                            gregs + INT_REGISTER_SIZE * regno);
 421
 422   if (regnum == ARM_PS_REGNUM || regnum == -1)
 423     {
 424       if (arm_apcs_32)
 425         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 426                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 427       else
 428         regcache_raw_supply (regcache, ARM_PS_REGNUM,
 429                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 430     }
 431
 432   if (regnum == ARM_PC_REGNUM || regnum == -1)
 433     {
 434       reg_pc = extract_unsigned_integer (gregs
 435                                          + INT_REGISTER_SIZE * ARM_PC_REGNUM,
 436                                          INT_REGISTER_SIZE, byte_order);
 437       reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
 438       store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
 439       regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
 440     }
 441 }
 442
 443 void
 444 arm_linux_collect_gregset (const struct regset *regset,
 445                            const struct regcache *regcache,
 446                            int regnum, void *gregs_buf, size_t len)
 447 {
 448   gdb_byte *gregs = gregs_buf;
 449   int regno;
 450
 451   for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
 452     if (regnum == -1 || regnum == regno)
 453       regcache_raw_collect (regcache, regno,
 454                             gregs + INT_REGISTER_SIZE * regno);
 455
 456   if (regnum == ARM_PS_REGNUM || regnum == -1)
 457     {
 458       if (arm_apcs_32)
 459         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 460                               gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
 461       else
 462         regcache_raw_collect (regcache, ARM_PS_REGNUM,
 463                               gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 464     }
 465
 466   if (regnum == ARM_PC_REGNUM || regnum == -1)
 467     regcache_raw_collect (regcache, ARM_PC_REGNUM,
 468                           gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
 469 }
 470
 471 /* Support for register format used by the NWFPE FPA emulator.  */
 472
 473 #define typeNone                0x00
 474 #define typeSingle              0x01
 475 #define typeDouble              0x02
 476 #define typeExtended            0x03
 477
 478 void
 479 supply_nwfpe_register (struct regcache *regcache, int regno,
 480                        const gdb_byte *regs)
 481 {
 482   const gdb_byte *reg_data;
 483   gdb_byte reg_tag;
 484   gdb_byte buf[FP_REGISTER_SIZE];
 485
 486   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 487   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 488   memset (buf, 0, FP_REGISTER_SIZE);
 489
 490   switch (reg_tag)
 491     {
 492     case typeSingle:
 493       memcpy (buf, reg_data, 4);
 494       break;
 495     case typeDouble:
 496       memcpy (buf, reg_data + 4, 4);
 497       memcpy (buf + 4, reg_data, 4);
 498       break;
 499     case typeExtended:
 500       /* We want sign and exponent, then least significant bits,
 501          then most significant.  NWFPE does sign, most, least.  */
 502       memcpy (buf, reg_data, 4);
 503       memcpy (buf + 4, reg_data + 8, 4);
 504       memcpy (buf + 8, reg_data + 4, 4);
 505       break;
 506     default:
 507       break;
 508     }
 509
 510   regcache_raw_supply (regcache, regno, buf);
 511 }
 512
 513 void
 514 collect_nwfpe_register (const struct regcache *regcache, int regno,
 515                         gdb_byte *regs)
 516 {
 517   gdb_byte *reg_data;
 518   gdb_byte reg_tag;
 519   gdb_byte buf[FP_REGISTER_SIZE];
 520
 521   regcache_raw_collect (regcache, regno, buf);
 522
 523   /* NOTE drow/2006-06-07: This code uses the tag already in the
 524      register buffer.  I've preserved that when moving the code
 525      from the native file to the target file.  But this doesn't
 526      always make sense.  */
 527
 528   reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
 529   reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 530
 531   switch (reg_tag)
 532     {
 533     case typeSingle:
 534       memcpy (reg_data, buf, 4);
 535       break;
 536     case typeDouble:
 537       memcpy (reg_data, buf + 4, 4);
 538       memcpy (reg_data + 4, buf, 4);
 539       break;
 540     case typeExtended:
 541       memcpy (reg_data, buf, 4);
 542       memcpy (reg_data + 4, buf + 8, 4);
 543       memcpy (reg_data + 8, buf + 4, 4);
 544       break;
 545     default:
 546       break;
 547     }
 548 }
 549
 550 void
 551 arm_linux_supply_nwfpe (const struct regset *regset,
 552                         struct regcache *regcache,
 553                         int regnum, const void *regs_buf, size_t len)
 554 {
 555   const gdb_byte *regs = regs_buf;
 556   int regno;
 557
 558   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 559     regcache_raw_supply (regcache, ARM_FPS_REGNUM,
 560                          regs + NWFPE_FPSR_OFFSET);
 561
 562   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 563     if (regnum == -1 || regnum == regno)
 564       supply_nwfpe_register (regcache, regno, regs);
 565 }
 566
 567 void
 568 arm_linux_collect_nwfpe (const struct regset *regset,
 569                          const struct regcache *regcache,
 570                          int regnum, void *regs_buf, size_t len)
 571 {
 572   gdb_byte *regs = regs_buf;
 573   int regno;
 574
 575   for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
 576     if (regnum == -1 || regnum == regno)
 577       collect_nwfpe_register (regcache, regno, regs);
 578
 579   if (regnum == ARM_FPS_REGNUM || regnum == -1)
 580     regcache_raw_collect (regcache, ARM_FPS_REGNUM,
 581                           regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
 582 }
 583
 584 /* Return the appropriate register set for the core section identified
 585    by SECT_NAME and SECT_SIZE.  */
 586
 587 static const struct regset *
 588 arm_linux_regset_from_core_section (struct gdbarch *gdbarch,
 589                                     const char *sect_name, size_t sect_size)
 590 {
 591   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 592
 593   if (strcmp (sect_name, ".reg") == 0
 594       && sect_size == ARM_LINUX_SIZEOF_GREGSET)
 595     {
 596       if (tdep->gregset == NULL)
 597         tdep->gregset = regset_alloc (gdbarch, arm_linux_supply_gregset,
 598                                       arm_linux_collect_gregset);
 599       return tdep->gregset;
 600     }
 601
 602   if (strcmp (sect_name, ".reg2") == 0
 603       && sect_size == ARM_LINUX_SIZEOF_NWFPE)
 604     {
 605       if (tdep->fpregset == NULL)
 606         tdep->fpregset = regset_alloc (gdbarch, arm_linux_supply_nwfpe,
 607                                        arm_linux_collect_nwfpe);
 608       return tdep->fpregset;
 609     }
 610
 611   return NULL;
 612 }
 613
 614 /* Insert a single step breakpoint at the next executed instruction.  */
 615
 616 static int
 617 arm_linux_software_single_step (struct frame_info *frame)
 618 {
 619   struct gdbarch *gdbarch = get_frame_arch (frame);
 620   struct address_space *aspace = get_frame_address_space (frame);
 621   CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
 622
 623   /* The Linux kernel offers some user-mode helpers in a high page.  We can
 624      not read this page (as of 2.6.23), and even if we could then we couldn't
 625      set breakpoints in it, and even if we could then the atomic operations
 626      would fail when interrupted.  They are all called as functions and return
 627      to the address in LR, so step to there instead.  */
 628   if (next_pc > 0xffff0000)
 629     next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
 630
 631   insert_single_step_breakpoint (gdbarch, aspace, next_pc);
 632
 633   return 1;
 634 }
 635
 636 /* Support for displaced stepping of Linux SVC instructions.  */
 637
 638 static void
 639 arm_linux_cleanup_svc (struct gdbarch *gdbarch ATTRIBUTE_UNUSED,
 640                        struct regcache *regs,
 641                        struct displaced_step_closure *dsc)
 642 {
 643   CORE_ADDR from = dsc->insn_addr;
 644   ULONGEST apparent_pc;
 645   int within_scratch;
 646
 647   regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
 648
 649   within_scratch = (apparent_pc >= dsc->scratch_base
 650                     && apparent_pc < (dsc->scratch_base
 651                                       + DISPLACED_MODIFIED_INSNS * 4 + 4));
 652
 653   if (debug_displaced)
 654     {
 655       fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
 656                           "SVC step ", (unsigned long) apparent_pc);
 657       if (within_scratch)
 658         fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
 659       else
 660         fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
 661     }
 662
 663   if (within_scratch)
 664     displaced_write_reg (regs, dsc, ARM_PC_REGNUM, from + 4, BRANCH_WRITE_PC);
 665 }
 666
 667 static int
 668 arm_linux_copy_svc (struct gdbarch *gdbarch, uint32_t insn, CORE_ADDR to,
 669                     struct regcache *regs, struct displaced_step_closure *dsc)
 670 {
 671   CORE_ADDR from = dsc->insn_addr;
 672   struct frame_info *frame;
 673   unsigned int svc_number = displaced_read_reg (regs, from, 7);
 674
 675   if (debug_displaced)
 676     fprintf_unfiltered (gdb_stdlog, "displaced: copying Linux svc insn %.8lx\n",
 677                         (unsigned long) insn);
 678
 679   frame = get_current_frame ();
 680
 681   /* Is this a sigreturn or rt_sigreturn syscall?  Note: these are only useful
 682      for EABI.  */
 683   if (svc_number == 119 || svc_number == 173)
 684     {
 685       if (get_frame_type (frame) == SIGTRAMP_FRAME)
 686         {
 687           CORE_ADDR return_to;
 688           struct symtab_and_line sal;
 689
 690           if (debug_displaced)
 691             fprintf_unfiltered (gdb_stdlog, "displaced: found "
 692               "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
 693               (unsigned long) get_frame_pc (frame));
 694
 695           return_to = frame_unwind_caller_pc (frame);
 696           if (debug_displaced)
 697             fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
 698               "Setting momentary breakpoint.\n", (unsigned long) return_to);
 699
 700           gdb_assert (inferior_thread ()->step_resume_breakpoint == NULL);
 701
 702           sal = find_pc_line (return_to, 0);
 703           sal.pc = return_to;
 704           sal.section = find_pc_overlay (return_to);
 705           sal.explicit_pc = 1;
 706
 707           frame = get_prev_frame (frame);
 708
 709           if (frame)
 710             {
 711               inferior_thread ()->step_resume_breakpoint
 712                 = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
 713                                             bp_step_resume);
 714
 715               /* We need to make sure we actually insert the momentary
 716                  breakpoint set above.  */
 717               insert_breakpoints ();
 718             }
 719           else if (debug_displaced)
 720             fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
 721                                 "frame to set momentary breakpoint for "
 722                                 "sigreturn/rt_sigreturn\n");
 723         }
 724       else if (debug_displaced)
 725         fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
 726                             "SVC call not in signal trampoline frame\n");
 727     }
 728
 729   /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
 730                   location, else nothing.
 731      Insn: unmodified svc.
 732      Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
 733               else leave pc alone.  */
 734
 735   dsc->modinsn[0] = insn;
 736
 737   dsc->cleanup = &arm_linux_cleanup_svc;
 738   /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
 739      instruction.  */
 740   dsc->wrote_to_pc = 1;
 741
 742   return 0;
 743 }
 744
 745
 746 /* The following two functions implement single-stepping over calls to Linux
 747    kernel helper routines, which perform e.g. atomic operations on architecture
 748    variants which don't support them natively.
 749
 750    When this function is called, the PC will be pointing at the kernel helper
 751    (at an address inaccessible to GDB), and r14 will point to the return
 752    address.  Displaced stepping always executes code in the copy area:
 753    so, make the copy-area instruction branch back to the kernel helper (the
 754    "from" address), and make r14 point to the breakpoint in the copy area.  In
 755    that way, we regain control once the kernel helper returns, and can clean
 756    up appropriately (as if we had just returned from the kernel helper as it
 757    would have been called from the non-displaced location).  */
 758
 759 static void
 760 cleanup_kernel_helper_return (struct gdbarch *gdbarch ATTRIBUTE_UNUSED,
 761                               struct regcache *regs,
 762                               struct displaced_step_closure *dsc)
 763 {
 764   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
 765   displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
 766 }
 767
 768 static void
 769 arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
 770                                 CORE_ADDR to, struct regcache *regs,
 771                                 struct displaced_step_closure *dsc)
 772 {
 773   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 774
 775   dsc->numinsns = 1;
 776   dsc->insn_addr = from;
 777   dsc->cleanup = &cleanup_kernel_helper_return;
 778   /* Say we wrote to the PC, else cleanup will set PC to the next
 779      instruction in the helper, which isn't helpful.  */
 780   dsc->wrote_to_pc = 1;
 781
 782   /* Preparation: tmp[0] <- r14
 783                   r14 <- <scratch space>+4
 784                   *(<scratch space>+8) <- from
 785      Insn: ldr pc, [r14, #4]
 786      Cleanup: r14 <- tmp[0], pc <- tmp[0].  */
 787
 788   dsc->tmp[0] = displaced_read_reg (regs, from, ARM_LR_REGNUM);
 789   displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
 790                        CANNOT_WRITE_PC);
 791   write_memory_unsigned_integer (to + 8, 4, byte_order, from);
 792
 793   dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
 794 }
 795
 796 /* Linux-specific displaced step instruction copying function.  Detects when
 797    the program has stepped into a Linux kernel helper routine (which must be
 798    handled as a special case), falling back to arm_displaced_step_copy_insn()
 799    if it hasn't.  */
 800
 801 static struct displaced_step_closure *
 802 arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
 803                                     CORE_ADDR from, CORE_ADDR to,
 804                                     struct regcache *regs)
 805 {
 806   struct displaced_step_closure *dsc
 807     = xmalloc (sizeof (struct displaced_step_closure));
 808
 809   /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
 810      stop at the return location.  */
 811   if (from > 0xffff0000)
 812     {
 813       if (debug_displaced)
 814         fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
 815                             "at %.8lx\n", (unsigned long) from);
 816
 817       arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
 818     }
 819   else
 820     {
 821       enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 822       uint32_t insn = read_memory_unsigned_integer (from, 4, byte_order);
 823
 824       if (debug_displaced)
 825         fprintf_unfiltered (gdb_stdlog, "displaced: stepping insn %.8lx "
 826                             "at %.8lx\n", (unsigned long) insn,
 827                             (unsigned long) from);
 828
 829       /* Override the default handling of SVC instructions.  */
 830       dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
 831
 832       arm_process_displaced_insn (gdbarch, insn, from, to, regs, dsc);
 833     }
 834
 835   arm_displaced_init_closure (gdbarch, from, to, dsc);
 836
 837   return dsc;
 838 }
 839
 840 static void
 841 arm_linux_init_abi (struct gdbarch_info info,
 842                     struct gdbarch *gdbarch)
 843 {
 844   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 845
 846   tdep->lowest_pc = 0x8000;
 847   if (info.byte_order == BFD_ENDIAN_BIG)
 848     {
 849       if (tdep->arm_abi == ARM_ABI_AAPCS)
 850         tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
 851       else
 852         tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
 853       tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
 854     }
 855   else
 856     {
 857       if (tdep->arm_abi == ARM_ABI_AAPCS)
 858         tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
 859       else
 860         tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
 861       tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
 862     }
 863   tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
 864   tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
 865
 866   if (tdep->fp_model == ARM_FLOAT_AUTO)
 867     tdep->fp_model = ARM_FLOAT_FPA;
 868
 869   tdep->jb_pc = ARM_LINUX_JB_PC;
 870   tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
 871
 872   set_solib_svr4_fetch_link_map_offsets
 873     (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 874
 875   /* Single stepping.  */
 876   set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
 877
 878   /* Shared library handling.  */
 879   set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
 880   set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 881
 882   /* Enable TLS support.  */
 883   set_gdbarch_fetch_tls_load_module_address (gdbarch,
 884                                              svr4_fetch_objfile_link_map);
 885
 886   tramp_frame_prepend_unwinder (gdbarch,
 887                                 &arm_linux_sigreturn_tramp_frame);
 888   tramp_frame_prepend_unwinder (gdbarch,
 889                                 &arm_linux_rt_sigreturn_tramp_frame);
 890   tramp_frame_prepend_unwinder (gdbarch,
 891                                 &arm_eabi_linux_sigreturn_tramp_frame);
 892   tramp_frame_prepend_unwinder (gdbarch,
 893                                 &arm_eabi_linux_rt_sigreturn_tramp_frame);
 894   tramp_frame_prepend_unwinder (gdbarch,
 895                                 &arm_linux_restart_syscall_tramp_frame);
 896
 897   /* Core file support.  */
 898   set_gdbarch_regset_from_core_section (gdbarch,
 899                                         arm_linux_regset_from_core_section);
 900
 901   set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
 902
 903   /* Displaced stepping.  */
 904   set_gdbarch_displaced_step_copy_insn (gdbarch,
 905                                         arm_linux_displaced_step_copy_insn);
 906   set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
 907   set_gdbarch_displaced_step_free_closure (gdbarch,
 908                                            simple_displaced_step_free_closure);
 909   set_gdbarch_displaced_step_location (gdbarch, displaced_step_at_entry_point);
 910 }
 911
 912 /* Provide a prototype to silence -Wmissing-prototypes.  */
 913 extern initialize_file_ftype _initialize_arm_linux_tdep;
 914
 915 void
 916 _initialize_arm_linux_tdep (void)
 917 {
 918   gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
 919                           arm_linux_init_abi);
 920 }