OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [arm-linux-tdep.c] - Diff between revs 227 and 816

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 227 Rev 816
/* GNU/Linux on ARM target support.
/* GNU/Linux on ARM target support.
 
 
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   2009, 2010 Free Software Foundation, Inc.
   2009, 2010 Free Software Foundation, Inc.
 
 
   This file is part of GDB.
   This file is part of GDB.
 
 
   This program is free software; you can redistribute it and/or modify
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.
   (at your option) any later version.
 
 
   This program is distributed in the hope that it will be useful,
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   GNU General Public License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 
#include "defs.h"
#include "defs.h"
#include "target.h"
#include "target.h"
#include "value.h"
#include "value.h"
#include "gdbtypes.h"
#include "gdbtypes.h"
#include "floatformat.h"
#include "floatformat.h"
#include "gdbcore.h"
#include "gdbcore.h"
#include "frame.h"
#include "frame.h"
#include "regcache.h"
#include "regcache.h"
#include "doublest.h"
#include "doublest.h"
#include "solib-svr4.h"
#include "solib-svr4.h"
#include "osabi.h"
#include "osabi.h"
#include "regset.h"
#include "regset.h"
#include "trad-frame.h"
#include "trad-frame.h"
#include "tramp-frame.h"
#include "tramp-frame.h"
#include "breakpoint.h"
#include "breakpoint.h"
 
 
#include "arm-tdep.h"
#include "arm-tdep.h"
#include "arm-linux-tdep.h"
#include "arm-linux-tdep.h"
#include "linux-tdep.h"
#include "linux-tdep.h"
#include "glibc-tdep.h"
#include "glibc-tdep.h"
#include "arch-utils.h"
#include "arch-utils.h"
#include "inferior.h"
#include "inferior.h"
#include "gdbthread.h"
#include "gdbthread.h"
#include "symfile.h"
#include "symfile.h"
 
 
#include "gdb_string.h"
#include "gdb_string.h"
 
 
extern int arm_apcs_32;
extern int arm_apcs_32;
 
 
/* Under ARM GNU/Linux the traditional way of performing a breakpoint
/* Under ARM GNU/Linux the traditional way of performing a breakpoint
   is to execute a particular software interrupt, rather than use a
   is to execute a particular software interrupt, rather than use a
   particular undefined instruction to provoke a trap.  Upon exection
   particular undefined instruction to provoke a trap.  Upon exection
   of the software interrupt the kernel stops the inferior with a
   of the software interrupt the kernel stops the inferior with a
   SIGTRAP, and wakes the debugger.  */
   SIGTRAP, and wakes the debugger.  */
 
 
static const char arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
static const char arm_linux_arm_le_breakpoint[] = { 0x01, 0x00, 0x9f, 0xef };
 
 
static const char arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
static const char arm_linux_arm_be_breakpoint[] = { 0xef, 0x9f, 0x00, 0x01 };
 
 
/* However, the EABI syscall interface (new in Nov. 2005) does not look at
/* However, the EABI syscall interface (new in Nov. 2005) does not look at
   the operand of the swi if old-ABI compatibility is disabled.  Therefore,
   the operand of the swi if old-ABI compatibility is disabled.  Therefore,
   use an undefined instruction instead.  This is supported as of kernel
   use an undefined instruction instead.  This is supported as of kernel
   version 2.5.70 (May 2003), so should be a safe assumption for EABI
   version 2.5.70 (May 2003), so should be a safe assumption for EABI
   binaries.  */
   binaries.  */
 
 
static const char eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
static const char eabi_linux_arm_le_breakpoint[] = { 0xf0, 0x01, 0xf0, 0xe7 };
 
 
static const char eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
static const char eabi_linux_arm_be_breakpoint[] = { 0xe7, 0xf0, 0x01, 0xf0 };
 
 
/* All the kernels which support Thumb support using a specific undefined
/* All the kernels which support Thumb support using a specific undefined
   instruction for the Thumb breakpoint.  */
   instruction for the Thumb breakpoint.  */
 
 
static const char arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
static const char arm_linux_thumb_be_breakpoint[] = {0xde, 0x01};
 
 
static const char arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
static const char arm_linux_thumb_le_breakpoint[] = {0x01, 0xde};
 
 
/* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
/* Because the 16-bit Thumb breakpoint is affected by Thumb-2 IT blocks,
   we must use a length-appropriate breakpoint for 32-bit Thumb
   we must use a length-appropriate breakpoint for 32-bit Thumb
   instructions.  See also thumb_get_next_pc.  */
   instructions.  See also thumb_get_next_pc.  */
 
 
static const char arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };
static const char arm_linux_thumb2_be_breakpoint[] = { 0xf7, 0xf0, 0xa0, 0x00 };
 
 
static const char arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 };
static const char arm_linux_thumb2_le_breakpoint[] = { 0xf0, 0xf7, 0x00, 0xa0 };
 
 
/* Description of the longjmp buffer.  */
/* Description of the longjmp buffer.  */
#define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_SIZE
#define ARM_LINUX_JB_ELEMENT_SIZE       INT_REGISTER_SIZE
#define ARM_LINUX_JB_PC                 21
#define ARM_LINUX_JB_PC                 21
 
 
/*
/*
   Dynamic Linking on ARM GNU/Linux
   Dynamic Linking on ARM GNU/Linux
   --------------------------------
   --------------------------------
 
 
   Note: PLT = procedure linkage table
   Note: PLT = procedure linkage table
   GOT = global offset table
   GOT = global offset table
 
 
   As much as possible, ELF dynamic linking defers the resolution of
   As much as possible, ELF dynamic linking defers the resolution of
   jump/call addresses until the last minute. The technique used is
   jump/call addresses until the last minute. The technique used is
   inspired by the i386 ELF design, and is based on the following
   inspired by the i386 ELF design, and is based on the following
   constraints.
   constraints.
 
 
   1) The calling technique should not force a change in the assembly
   1) The calling technique should not force a change in the assembly
   code produced for apps; it MAY cause changes in the way assembly
   code produced for apps; it MAY cause changes in the way assembly
   code is produced for position independent code (i.e. shared
   code is produced for position independent code (i.e. shared
   libraries).
   libraries).
 
 
   2) The technique must be such that all executable areas must not be
   2) The technique must be such that all executable areas must not be
   modified; and any modified areas must not be executed.
   modified; and any modified areas must not be executed.
 
 
   To do this, there are three steps involved in a typical jump:
   To do this, there are three steps involved in a typical jump:
 
 
   1) in the code
   1) in the code
   2) through the PLT
   2) through the PLT
   3) using a pointer from the GOT
   3) using a pointer from the GOT
 
 
   When the executable or library is first loaded, each GOT entry is
   When the executable or library is first loaded, each GOT entry is
   initialized to point to the code which implements dynamic name
   initialized to point to the code which implements dynamic name
   resolution and code finding.  This is normally a function in the
   resolution and code finding.  This is normally a function in the
   program interpreter (on ARM GNU/Linux this is usually
   program interpreter (on ARM GNU/Linux this is usually
   ld-linux.so.2, but it does not have to be).  On the first
   ld-linux.so.2, but it does not have to be).  On the first
   invocation, the function is located and the GOT entry is replaced
   invocation, the function is located and the GOT entry is replaced
   with the real function address.  Subsequent calls go through steps
   with the real function address.  Subsequent calls go through steps
   1, 2 and 3 and end up calling the real code.
   1, 2 and 3 and end up calling the real code.
 
 
   1) In the code:
   1) In the code:
 
 
   b    function_call
   b    function_call
   bl   function_call
   bl   function_call
 
 
   This is typical ARM code using the 26 bit relative branch or branch
   This is typical ARM code using the 26 bit relative branch or branch
   and link instructions.  The target of the instruction
   and link instructions.  The target of the instruction
   (function_call is usually the address of the function to be called.
   (function_call is usually the address of the function to be called.
   In position independent code, the target of the instruction is
   In position independent code, the target of the instruction is
   actually an entry in the PLT when calling functions in a shared
   actually an entry in the PLT when calling functions in a shared
   library.  Note that this call is identical to a normal function
   library.  Note that this call is identical to a normal function
   call, only the target differs.
   call, only the target differs.
 
 
   2) In the PLT:
   2) In the PLT:
 
 
   The PLT is a synthetic area, created by the linker. It exists in
   The PLT is a synthetic area, created by the linker. It exists in
   both executables and libraries. It is an array of stubs, one per
   both executables and libraries. It is an array of stubs, one per
   imported function call. It looks like this:
   imported function call. It looks like this:
 
 
   PLT[0]:
   PLT[0]:
   str     lr, [sp, #-4]!       @push the return address (lr)
   str     lr, [sp, #-4]!       @push the return address (lr)
   ldr     lr, [pc, #16]   @load from 6 words ahead
   ldr     lr, [pc, #16]   @load from 6 words ahead
   add     lr, pc, lr      @form an address for GOT[0]
   add     lr, pc, lr      @form an address for GOT[0]
   ldr     pc, [lr, #8]!   @jump to the contents of that addr
   ldr     pc, [lr, #8]!   @jump to the contents of that addr
 
 
   The return address (lr) is pushed on the stack and used for
   The return address (lr) is pushed on the stack and used for
   calculations.  The load on the second line loads the lr with
   calculations.  The load on the second line loads the lr with
   &GOT[3] - . - 20.  The addition on the third leaves:
   &GOT[3] - . - 20.  The addition on the third leaves:
 
 
   lr = (&GOT[3] - . - 20) + (. + 8)
   lr = (&GOT[3] - . - 20) + (. + 8)
   lr = (&GOT[3] - 12)
   lr = (&GOT[3] - 12)
   lr = &GOT[0]
   lr = &GOT[0]
 
 
   On the fourth line, the pc and lr are both updated, so that:
   On the fourth line, the pc and lr are both updated, so that:
 
 
   pc = GOT[2]
   pc = GOT[2]
   lr = &GOT[0] + 8
   lr = &GOT[0] + 8
   = &GOT[2]
   = &GOT[2]
 
 
   NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
   NOTE: PLT[0] borrows an offset .word from PLT[1]. This is a little
   "tight", but allows us to keep all the PLT entries the same size.
   "tight", but allows us to keep all the PLT entries the same size.
 
 
   PLT[n+1]:
   PLT[n+1]:
   ldr     ip, [pc, #4]    @load offset from gotoff
   ldr     ip, [pc, #4]    @load offset from gotoff
   add     ip, pc, ip      @add the offset to the pc
   add     ip, pc, ip      @add the offset to the pc
   ldr     pc, [ip]        @jump to that address
   ldr     pc, [ip]        @jump to that address
   gotoff: .word   GOT[n+3] - .
   gotoff: .word   GOT[n+3] - .
 
 
   The load on the first line, gets an offset from the fourth word of
   The load on the first line, gets an offset from the fourth word of
   the PLT entry.  The add on the second line makes ip = &GOT[n+3],
   the PLT entry.  The add on the second line makes ip = &GOT[n+3],
   which contains either a pointer to PLT[0] (the fixup trampoline) or
   which contains either a pointer to PLT[0] (the fixup trampoline) or
   a pointer to the actual code.
   a pointer to the actual code.
 
 
   3) In the GOT:
   3) In the GOT:
 
 
   The GOT contains helper pointers for both code (PLT) fixups and
   The GOT contains helper pointers for both code (PLT) fixups and
   data fixups.  The first 3 entries of the GOT are special. The next
   data fixups.  The first 3 entries of the GOT are special. The next
   M entries (where M is the number of entries in the PLT) belong to
   M entries (where M is the number of entries in the PLT) belong to
   the PLT fixups. The next D (all remaining) entries belong to
   the PLT fixups. The next D (all remaining) entries belong to
   various data fixups. The actual size of the GOT is 3 + M + D.
   various data fixups. The actual size of the GOT is 3 + M + D.
 
 
   The GOT is also a synthetic area, created by the linker. It exists
   The GOT is also a synthetic area, created by the linker. It exists
   in both executables and libraries.  When the GOT is first
   in both executables and libraries.  When the GOT is first
   initialized , all the GOT entries relating to PLT fixups are
   initialized , all the GOT entries relating to PLT fixups are
   pointing to code back at PLT[0].
   pointing to code back at PLT[0].
 
 
   The special entries in the GOT are:
   The special entries in the GOT are:
 
 
   GOT[0] = linked list pointer used by the dynamic loader
   GOT[0] = linked list pointer used by the dynamic loader
   GOT[1] = pointer to the reloc table for this module
   GOT[1] = pointer to the reloc table for this module
   GOT[2] = pointer to the fixup/resolver code
   GOT[2] = pointer to the fixup/resolver code
 
 
   The first invocation of function call comes through and uses the
   The first invocation of function call comes through and uses the
   fixup/resolver code.  On the entry to the fixup/resolver code:
   fixup/resolver code.  On the entry to the fixup/resolver code:
 
 
   ip = &GOT[n+3]
   ip = &GOT[n+3]
   lr = &GOT[2]
   lr = &GOT[2]
   stack[0] = return address (lr) of the function call
   stack[0] = return address (lr) of the function call
   [r0, r1, r2, r3] are still the arguments to the function call
   [r0, r1, r2, r3] are still the arguments to the function call
 
 
   This is enough information for the fixup/resolver code to work
   This is enough information for the fixup/resolver code to work
   with.  Before the fixup/resolver code returns, it actually calls
   with.  Before the fixup/resolver code returns, it actually calls
   the requested function and repairs &GOT[n+3].  */
   the requested function and repairs &GOT[n+3].  */
 
 
/* The constants below were determined by examining the following files
/* The constants below were determined by examining the following files
   in the linux kernel sources:
   in the linux kernel sources:
 
 
      arch/arm/kernel/signal.c
      arch/arm/kernel/signal.c
          - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
          - see SWI_SYS_SIGRETURN and SWI_SYS_RT_SIGRETURN
      include/asm-arm/unistd.h
      include/asm-arm/unistd.h
          - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
          - see __NR_sigreturn, __NR_rt_sigreturn, and __NR_SYSCALL_BASE */
 
 
#define ARM_LINUX_SIGRETURN_INSTR       0xef900077
#define ARM_LINUX_SIGRETURN_INSTR       0xef900077
#define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
#define ARM_LINUX_RT_SIGRETURN_INSTR    0xef9000ad
 
 
/* For ARM EABI, the syscall number is not in the SWI instruction
/* For ARM EABI, the syscall number is not in the SWI instruction
   (instead it is loaded into r7).  We recognize the pattern that
   (instead it is loaded into r7).  We recognize the pattern that
   glibc uses...  alternatively, we could arrange to do this by
   glibc uses...  alternatively, we could arrange to do this by
   function name, but they are not always exported.  */
   function name, but they are not always exported.  */
#define ARM_SET_R7_SIGRETURN            0xe3a07077
#define ARM_SET_R7_SIGRETURN            0xe3a07077
#define ARM_SET_R7_RT_SIGRETURN         0xe3a070ad
#define ARM_SET_R7_RT_SIGRETURN         0xe3a070ad
#define ARM_EABI_SYSCALL                0xef000000
#define ARM_EABI_SYSCALL                0xef000000
 
 
/* OABI syscall restart trampoline, used for EABI executables too
/* OABI syscall restart trampoline, used for EABI executables too
   whenever OABI support has been enabled in the kernel.  */
   whenever OABI support has been enabled in the kernel.  */
#define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
#define ARM_OABI_SYSCALL_RESTART_SYSCALL 0xef900000
#define ARM_LDR_PC_SP_12                0xe49df00c
#define ARM_LDR_PC_SP_12                0xe49df00c
 
 
static void
static void
arm_linux_sigtramp_cache (struct frame_info *this_frame,
arm_linux_sigtramp_cache (struct frame_info *this_frame,
                          struct trad_frame_cache *this_cache,
                          struct trad_frame_cache *this_cache,
                          CORE_ADDR func, int regs_offset)
                          CORE_ADDR func, int regs_offset)
{
{
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  CORE_ADDR base = sp + regs_offset;
  CORE_ADDR base = sp + regs_offset;
  int i;
  int i;
 
 
  for (i = 0; i < 16; i++)
  for (i = 0; i < 16; i++)
    trad_frame_set_reg_addr (this_cache, i, base + i * 4);
    trad_frame_set_reg_addr (this_cache, i, base + i * 4);
 
 
  trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
  trad_frame_set_reg_addr (this_cache, ARM_PS_REGNUM, base + 16 * 4);
 
 
  /* The VFP or iWMMXt registers may be saved on the stack, but there's
  /* The VFP or iWMMXt registers may be saved on the stack, but there's
     no reliable way to restore them (yet).  */
     no reliable way to restore them (yet).  */
 
 
  /* Save a frame ID.  */
  /* Save a frame ID.  */
  trad_frame_set_id (this_cache, frame_id_build (sp, func));
  trad_frame_set_id (this_cache, frame_id_build (sp, func));
}
}
 
 
/* There are a couple of different possible stack layouts that
/* There are a couple of different possible stack layouts that
   we need to support.
   we need to support.
 
 
   Before version 2.6.18, the kernel used completely independent
   Before version 2.6.18, the kernel used completely independent
   layouts for non-RT and RT signals.  For non-RT signals the stack
   layouts for non-RT and RT signals.  For non-RT signals the stack
   began directly with a struct sigcontext.  For RT signals the stack
   began directly with a struct sigcontext.  For RT signals the stack
   began with two redundant pointers (to the siginfo and ucontext),
   began with two redundant pointers (to the siginfo and ucontext),
   and then the siginfo and ucontext.
   and then the siginfo and ucontext.
 
 
   As of version 2.6.18, the non-RT signal frame layout starts with
   As of version 2.6.18, the non-RT signal frame layout starts with
   a ucontext and the RT signal frame starts with a siginfo and then
   a ucontext and the RT signal frame starts with a siginfo and then
   a ucontext.  Also, the ucontext now has a designated save area
   a ucontext.  Also, the ucontext now has a designated save area
   for coprocessor registers.
   for coprocessor registers.
 
 
   For RT signals, it's easy to tell the difference: we look for
   For RT signals, it's easy to tell the difference: we look for
   pinfo, the pointer to the siginfo.  If it has the expected
   pinfo, the pointer to the siginfo.  If it has the expected
   value, we have an old layout.  If it doesn't, we have the new
   value, we have an old layout.  If it doesn't, we have the new
   layout.
   layout.
 
 
   For non-RT signals, it's a bit harder.  We need something in one
   For non-RT signals, it's a bit harder.  We need something in one
   layout or the other with a recognizable offset and value.  We can't
   layout or the other with a recognizable offset and value.  We can't
   use the return trampoline, because ARM usually uses SA_RESTORER,
   use the return trampoline, because ARM usually uses SA_RESTORER,
   in which case the stack return trampoline is not filled in.
   in which case the stack return trampoline is not filled in.
   We can't use the saved stack pointer, because sigaltstack might
   We can't use the saved stack pointer, because sigaltstack might
   be in use.  So for now we guess the new layout...  */
   be in use.  So for now we guess the new layout...  */
 
 
/* There are three words (trap_no, error_code, oldmask) in
/* There are three words (trap_no, error_code, oldmask) in
   struct sigcontext before r0.  */
   struct sigcontext before r0.  */
#define ARM_SIGCONTEXT_R0 0xc
#define ARM_SIGCONTEXT_R0 0xc
 
 
/* There are five words (uc_flags, uc_link, and three for uc_stack)
/* There are five words (uc_flags, uc_link, and three for uc_stack)
   in the ucontext_t before the sigcontext.  */
   in the ucontext_t before the sigcontext.  */
#define ARM_UCONTEXT_SIGCONTEXT 0x14
#define ARM_UCONTEXT_SIGCONTEXT 0x14
 
 
/* There are three elements in an rt_sigframe before the ucontext:
/* There are three elements in an rt_sigframe before the ucontext:
   pinfo, puc, and info.  The first two are pointers and the third
   pinfo, puc, and info.  The first two are pointers and the third
   is a struct siginfo, with size 128 bytes.  We could follow puc
   is a struct siginfo, with size 128 bytes.  We could follow puc
   to the ucontext, but it's simpler to skip the whole thing.  */
   to the ucontext, but it's simpler to skip the whole thing.  */
#define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
#define ARM_OLD_RT_SIGFRAME_SIGINFO 0x8
#define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
#define ARM_OLD_RT_SIGFRAME_UCONTEXT 0x88
 
 
#define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
#define ARM_NEW_RT_SIGFRAME_UCONTEXT 0x80
 
 
#define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
#define ARM_NEW_SIGFRAME_MAGIC 0x5ac3c35a
 
 
static void
static void
arm_linux_sigreturn_init (const struct tramp_frame *self,
arm_linux_sigreturn_init (const struct tramp_frame *self,
                          struct frame_info *this_frame,
                          struct frame_info *this_frame,
                          struct trad_frame_cache *this_cache,
                          struct trad_frame_cache *this_cache,
                          CORE_ADDR func)
                          CORE_ADDR func)
{
{
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
  ULONGEST uc_flags = read_memory_unsigned_integer (sp, 4, byte_order);
 
 
  if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
  if (uc_flags == ARM_NEW_SIGFRAME_MAGIC)
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
                              ARM_UCONTEXT_SIGCONTEXT
                              ARM_UCONTEXT_SIGCONTEXT
                              + ARM_SIGCONTEXT_R0);
                              + ARM_SIGCONTEXT_R0);
  else
  else
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
                              ARM_SIGCONTEXT_R0);
                              ARM_SIGCONTEXT_R0);
}
}
 
 
static void
static void
arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
arm_linux_rt_sigreturn_init (const struct tramp_frame *self,
                          struct frame_info *this_frame,
                          struct frame_info *this_frame,
                          struct trad_frame_cache *this_cache,
                          struct trad_frame_cache *this_cache,
                          CORE_ADDR func)
                          CORE_ADDR func)
{
{
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  struct gdbarch *gdbarch = get_frame_arch (this_frame);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
  ULONGEST pinfo = read_memory_unsigned_integer (sp, 4, byte_order);
 
 
  if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
  if (pinfo == sp + ARM_OLD_RT_SIGFRAME_SIGINFO)
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
                              ARM_OLD_RT_SIGFRAME_UCONTEXT
                              ARM_OLD_RT_SIGFRAME_UCONTEXT
                              + ARM_UCONTEXT_SIGCONTEXT
                              + ARM_UCONTEXT_SIGCONTEXT
                              + ARM_SIGCONTEXT_R0);
                              + ARM_SIGCONTEXT_R0);
  else
  else
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
    arm_linux_sigtramp_cache (this_frame, this_cache, func,
                              ARM_NEW_RT_SIGFRAME_UCONTEXT
                              ARM_NEW_RT_SIGFRAME_UCONTEXT
                              + ARM_UCONTEXT_SIGCONTEXT
                              + ARM_UCONTEXT_SIGCONTEXT
                              + ARM_SIGCONTEXT_R0);
                              + ARM_SIGCONTEXT_R0);
}
}
 
 
static void
static void
arm_linux_restart_syscall_init (const struct tramp_frame *self,
arm_linux_restart_syscall_init (const struct tramp_frame *self,
                                struct frame_info *this_frame,
                                struct frame_info *this_frame,
                                struct trad_frame_cache *this_cache,
                                struct trad_frame_cache *this_cache,
                                CORE_ADDR func)
                                CORE_ADDR func)
{
{
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
  CORE_ADDR sp = get_frame_register_unsigned (this_frame, ARM_SP_REGNUM);
 
 
  trad_frame_set_reg_addr (this_cache, ARM_PC_REGNUM, sp);
  trad_frame_set_reg_addr (this_cache, ARM_PC_REGNUM, sp);
  trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + 12);
  trad_frame_set_reg_value (this_cache, ARM_SP_REGNUM, sp + 12);
 
 
  /* Save a frame ID.  */
  /* Save a frame ID.  */
  trad_frame_set_id (this_cache, frame_id_build (sp, func));
  trad_frame_set_id (this_cache, frame_id_build (sp, func));
}
}
 
 
static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
static struct tramp_frame arm_linux_sigreturn_tramp_frame = {
  SIGTRAMP_FRAME,
  SIGTRAMP_FRAME,
  4,
  4,
  {
  {
    { ARM_LINUX_SIGRETURN_INSTR, -1 },
    { ARM_LINUX_SIGRETURN_INSTR, -1 },
    { TRAMP_SENTINEL_INSN }
    { TRAMP_SENTINEL_INSN }
  },
  },
  arm_linux_sigreturn_init
  arm_linux_sigreturn_init
};
};
 
 
static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
static struct tramp_frame arm_linux_rt_sigreturn_tramp_frame = {
  SIGTRAMP_FRAME,
  SIGTRAMP_FRAME,
  4,
  4,
  {
  {
    { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
    { ARM_LINUX_RT_SIGRETURN_INSTR, -1 },
    { TRAMP_SENTINEL_INSN }
    { TRAMP_SENTINEL_INSN }
  },
  },
  arm_linux_rt_sigreturn_init
  arm_linux_rt_sigreturn_init
};
};
 
 
static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
static struct tramp_frame arm_eabi_linux_sigreturn_tramp_frame = {
  SIGTRAMP_FRAME,
  SIGTRAMP_FRAME,
  4,
  4,
  {
  {
    { ARM_SET_R7_SIGRETURN, -1 },
    { ARM_SET_R7_SIGRETURN, -1 },
    { ARM_EABI_SYSCALL, -1 },
    { ARM_EABI_SYSCALL, -1 },
    { TRAMP_SENTINEL_INSN }
    { TRAMP_SENTINEL_INSN }
  },
  },
  arm_linux_sigreturn_init
  arm_linux_sigreturn_init
};
};
 
 
static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
static struct tramp_frame arm_eabi_linux_rt_sigreturn_tramp_frame = {
  SIGTRAMP_FRAME,
  SIGTRAMP_FRAME,
  4,
  4,
  {
  {
    { ARM_SET_R7_RT_SIGRETURN, -1 },
    { ARM_SET_R7_RT_SIGRETURN, -1 },
    { ARM_EABI_SYSCALL, -1 },
    { ARM_EABI_SYSCALL, -1 },
    { TRAMP_SENTINEL_INSN }
    { TRAMP_SENTINEL_INSN }
  },
  },
  arm_linux_rt_sigreturn_init
  arm_linux_rt_sigreturn_init
};
};
 
 
static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
static struct tramp_frame arm_linux_restart_syscall_tramp_frame = {
  NORMAL_FRAME,
  NORMAL_FRAME,
  4,
  4,
  {
  {
    { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
    { ARM_OABI_SYSCALL_RESTART_SYSCALL, -1 },
    { ARM_LDR_PC_SP_12, -1 },
    { ARM_LDR_PC_SP_12, -1 },
    { TRAMP_SENTINEL_INSN }
    { TRAMP_SENTINEL_INSN }
  },
  },
  arm_linux_restart_syscall_init
  arm_linux_restart_syscall_init
};
};
 
 
/* Core file and register set support.  */
/* Core file and register set support.  */
 
 
#define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
#define ARM_LINUX_SIZEOF_GREGSET (18 * INT_REGISTER_SIZE)
 
 
void
void
arm_linux_supply_gregset (const struct regset *regset,
arm_linux_supply_gregset (const struct regset *regset,
                          struct regcache *regcache,
                          struct regcache *regcache,
                          int regnum, const void *gregs_buf, size_t len)
                          int regnum, const void *gregs_buf, size_t len)
{
{
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  const gdb_byte *gregs = gregs_buf;
  const gdb_byte *gregs = gregs_buf;
  int regno;
  int regno;
  CORE_ADDR reg_pc;
  CORE_ADDR reg_pc;
  gdb_byte pc_buf[INT_REGISTER_SIZE];
  gdb_byte pc_buf[INT_REGISTER_SIZE];
 
 
  for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
  for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
    if (regnum == -1 || regnum == regno)
    if (regnum == -1 || regnum == regno)
      regcache_raw_supply (regcache, regno,
      regcache_raw_supply (regcache, regno,
                           gregs + INT_REGISTER_SIZE * regno);
                           gregs + INT_REGISTER_SIZE * regno);
 
 
  if (regnum == ARM_PS_REGNUM || regnum == -1)
  if (regnum == ARM_PS_REGNUM || regnum == -1)
    {
    {
      if (arm_apcs_32)
      if (arm_apcs_32)
        regcache_raw_supply (regcache, ARM_PS_REGNUM,
        regcache_raw_supply (regcache, ARM_PS_REGNUM,
                             gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
                             gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
      else
      else
        regcache_raw_supply (regcache, ARM_PS_REGNUM,
        regcache_raw_supply (regcache, ARM_PS_REGNUM,
                             gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
                             gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
    }
    }
 
 
  if (regnum == ARM_PC_REGNUM || regnum == -1)
  if (regnum == ARM_PC_REGNUM || regnum == -1)
    {
    {
      reg_pc = extract_unsigned_integer (gregs
      reg_pc = extract_unsigned_integer (gregs
                                         + INT_REGISTER_SIZE * ARM_PC_REGNUM,
                                         + INT_REGISTER_SIZE * ARM_PC_REGNUM,
                                         INT_REGISTER_SIZE, byte_order);
                                         INT_REGISTER_SIZE, byte_order);
      reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
      reg_pc = gdbarch_addr_bits_remove (gdbarch, reg_pc);
      store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
      store_unsigned_integer (pc_buf, INT_REGISTER_SIZE, byte_order, reg_pc);
      regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
      regcache_raw_supply (regcache, ARM_PC_REGNUM, pc_buf);
    }
    }
}
}
 
 
void
void
arm_linux_collect_gregset (const struct regset *regset,
arm_linux_collect_gregset (const struct regset *regset,
                           const struct regcache *regcache,
                           const struct regcache *regcache,
                           int regnum, void *gregs_buf, size_t len)
                           int regnum, void *gregs_buf, size_t len)
{
{
  gdb_byte *gregs = gregs_buf;
  gdb_byte *gregs = gregs_buf;
  int regno;
  int regno;
 
 
  for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
  for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
    if (regnum == -1 || regnum == regno)
    if (regnum == -1 || regnum == regno)
      regcache_raw_collect (regcache, regno,
      regcache_raw_collect (regcache, regno,
                            gregs + INT_REGISTER_SIZE * regno);
                            gregs + INT_REGISTER_SIZE * regno);
 
 
  if (regnum == ARM_PS_REGNUM || regnum == -1)
  if (regnum == ARM_PS_REGNUM || regnum == -1)
    {
    {
      if (arm_apcs_32)
      if (arm_apcs_32)
        regcache_raw_collect (regcache, ARM_PS_REGNUM,
        regcache_raw_collect (regcache, ARM_PS_REGNUM,
                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
                              gregs + INT_REGISTER_SIZE * ARM_CPSR_GREGNUM);
      else
      else
        regcache_raw_collect (regcache, ARM_PS_REGNUM,
        regcache_raw_collect (regcache, ARM_PS_REGNUM,
                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
                              gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
    }
    }
 
 
  if (regnum == ARM_PC_REGNUM || regnum == -1)
  if (regnum == ARM_PC_REGNUM || regnum == -1)
    regcache_raw_collect (regcache, ARM_PC_REGNUM,
    regcache_raw_collect (regcache, ARM_PC_REGNUM,
                          gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
                          gregs + INT_REGISTER_SIZE * ARM_PC_REGNUM);
}
}
 
 
/* Support for register format used by the NWFPE FPA emulator.  */
/* Support for register format used by the NWFPE FPA emulator.  */
 
 
#define typeNone                0x00
#define typeNone                0x00
#define typeSingle              0x01
#define typeSingle              0x01
#define typeDouble              0x02
#define typeDouble              0x02
#define typeExtended            0x03
#define typeExtended            0x03
 
 
void
void
supply_nwfpe_register (struct regcache *regcache, int regno,
supply_nwfpe_register (struct regcache *regcache, int regno,
                       const gdb_byte *regs)
                       const gdb_byte *regs)
{
{
  const gdb_byte *reg_data;
  const gdb_byte *reg_data;
  gdb_byte reg_tag;
  gdb_byte reg_tag;
  gdb_byte buf[FP_REGISTER_SIZE];
  gdb_byte buf[FP_REGISTER_SIZE];
 
 
  reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
  reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
  reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
  reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
  memset (buf, 0, FP_REGISTER_SIZE);
  memset (buf, 0, FP_REGISTER_SIZE);
 
 
  switch (reg_tag)
  switch (reg_tag)
    {
    {
    case typeSingle:
    case typeSingle:
      memcpy (buf, reg_data, 4);
      memcpy (buf, reg_data, 4);
      break;
      break;
    case typeDouble:
    case typeDouble:
      memcpy (buf, reg_data + 4, 4);
      memcpy (buf, reg_data + 4, 4);
      memcpy (buf + 4, reg_data, 4);
      memcpy (buf + 4, reg_data, 4);
      break;
      break;
    case typeExtended:
    case typeExtended:
      /* We want sign and exponent, then least significant bits,
      /* We want sign and exponent, then least significant bits,
         then most significant.  NWFPE does sign, most, least.  */
         then most significant.  NWFPE does sign, most, least.  */
      memcpy (buf, reg_data, 4);
      memcpy (buf, reg_data, 4);
      memcpy (buf + 4, reg_data + 8, 4);
      memcpy (buf + 4, reg_data + 8, 4);
      memcpy (buf + 8, reg_data + 4, 4);
      memcpy (buf + 8, reg_data + 4, 4);
      break;
      break;
    default:
    default:
      break;
      break;
    }
    }
 
 
  regcache_raw_supply (regcache, regno, buf);
  regcache_raw_supply (regcache, regno, buf);
}
}
 
 
void
void
collect_nwfpe_register (const struct regcache *regcache, int regno,
collect_nwfpe_register (const struct regcache *regcache, int regno,
                        gdb_byte *regs)
                        gdb_byte *regs)
{
{
  gdb_byte *reg_data;
  gdb_byte *reg_data;
  gdb_byte reg_tag;
  gdb_byte reg_tag;
  gdb_byte buf[FP_REGISTER_SIZE];
  gdb_byte buf[FP_REGISTER_SIZE];
 
 
  regcache_raw_collect (regcache, regno, buf);
  regcache_raw_collect (regcache, regno, buf);
 
 
  /* NOTE drow/2006-06-07: This code uses the tag already in the
  /* NOTE drow/2006-06-07: This code uses the tag already in the
     register buffer.  I've preserved that when moving the code
     register buffer.  I've preserved that when moving the code
     from the native file to the target file.  But this doesn't
     from the native file to the target file.  But this doesn't
     always make sense.  */
     always make sense.  */
 
 
  reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
  reg_data = regs + (regno - ARM_F0_REGNUM) * FP_REGISTER_SIZE;
  reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
  reg_tag = regs[(regno - ARM_F0_REGNUM) + NWFPE_TAGS_OFFSET];
 
 
  switch (reg_tag)
  switch (reg_tag)
    {
    {
    case typeSingle:
    case typeSingle:
      memcpy (reg_data, buf, 4);
      memcpy (reg_data, buf, 4);
      break;
      break;
    case typeDouble:
    case typeDouble:
      memcpy (reg_data, buf + 4, 4);
      memcpy (reg_data, buf + 4, 4);
      memcpy (reg_data + 4, buf, 4);
      memcpy (reg_data + 4, buf, 4);
      break;
      break;
    case typeExtended:
    case typeExtended:
      memcpy (reg_data, buf, 4);
      memcpy (reg_data, buf, 4);
      memcpy (reg_data + 4, buf + 8, 4);
      memcpy (reg_data + 4, buf + 8, 4);
      memcpy (reg_data + 8, buf + 4, 4);
      memcpy (reg_data + 8, buf + 4, 4);
      break;
      break;
    default:
    default:
      break;
      break;
    }
    }
}
}
 
 
void
void
arm_linux_supply_nwfpe (const struct regset *regset,
arm_linux_supply_nwfpe (const struct regset *regset,
                        struct regcache *regcache,
                        struct regcache *regcache,
                        int regnum, const void *regs_buf, size_t len)
                        int regnum, const void *regs_buf, size_t len)
{
{
  const gdb_byte *regs = regs_buf;
  const gdb_byte *regs = regs_buf;
  int regno;
  int regno;
 
 
  if (regnum == ARM_FPS_REGNUM || regnum == -1)
  if (regnum == ARM_FPS_REGNUM || regnum == -1)
    regcache_raw_supply (regcache, ARM_FPS_REGNUM,
    regcache_raw_supply (regcache, ARM_FPS_REGNUM,
                         regs + NWFPE_FPSR_OFFSET);
                         regs + NWFPE_FPSR_OFFSET);
 
 
  for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
  for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
    if (regnum == -1 || regnum == regno)
    if (regnum == -1 || regnum == regno)
      supply_nwfpe_register (regcache, regno, regs);
      supply_nwfpe_register (regcache, regno, regs);
}
}
 
 
void
void
arm_linux_collect_nwfpe (const struct regset *regset,
arm_linux_collect_nwfpe (const struct regset *regset,
                         const struct regcache *regcache,
                         const struct regcache *regcache,
                         int regnum, void *regs_buf, size_t len)
                         int regnum, void *regs_buf, size_t len)
{
{
  gdb_byte *regs = regs_buf;
  gdb_byte *regs = regs_buf;
  int regno;
  int regno;
 
 
  for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
  for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
    if (regnum == -1 || regnum == regno)
    if (regnum == -1 || regnum == regno)
      collect_nwfpe_register (regcache, regno, regs);
      collect_nwfpe_register (regcache, regno, regs);
 
 
  if (regnum == ARM_FPS_REGNUM || regnum == -1)
  if (regnum == ARM_FPS_REGNUM || regnum == -1)
    regcache_raw_collect (regcache, ARM_FPS_REGNUM,
    regcache_raw_collect (regcache, ARM_FPS_REGNUM,
                          regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
                          regs + INT_REGISTER_SIZE * ARM_FPS_REGNUM);
}
}
 
 
/* Return the appropriate register set for the core section identified
/* Return the appropriate register set for the core section identified
   by SECT_NAME and SECT_SIZE.  */
   by SECT_NAME and SECT_SIZE.  */
 
 
static const struct regset *
static const struct regset *
arm_linux_regset_from_core_section (struct gdbarch *gdbarch,
arm_linux_regset_from_core_section (struct gdbarch *gdbarch,
                                    const char *sect_name, size_t sect_size)
                                    const char *sect_name, size_t sect_size)
{
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
 
  if (strcmp (sect_name, ".reg") == 0
  if (strcmp (sect_name, ".reg") == 0
      && sect_size == ARM_LINUX_SIZEOF_GREGSET)
      && sect_size == ARM_LINUX_SIZEOF_GREGSET)
    {
    {
      if (tdep->gregset == NULL)
      if (tdep->gregset == NULL)
        tdep->gregset = regset_alloc (gdbarch, arm_linux_supply_gregset,
        tdep->gregset = regset_alloc (gdbarch, arm_linux_supply_gregset,
                                      arm_linux_collect_gregset);
                                      arm_linux_collect_gregset);
      return tdep->gregset;
      return tdep->gregset;
    }
    }
 
 
  if (strcmp (sect_name, ".reg2") == 0
  if (strcmp (sect_name, ".reg2") == 0
      && sect_size == ARM_LINUX_SIZEOF_NWFPE)
      && sect_size == ARM_LINUX_SIZEOF_NWFPE)
    {
    {
      if (tdep->fpregset == NULL)
      if (tdep->fpregset == NULL)
        tdep->fpregset = regset_alloc (gdbarch, arm_linux_supply_nwfpe,
        tdep->fpregset = regset_alloc (gdbarch, arm_linux_supply_nwfpe,
                                       arm_linux_collect_nwfpe);
                                       arm_linux_collect_nwfpe);
      return tdep->fpregset;
      return tdep->fpregset;
    }
    }
 
 
  return NULL;
  return NULL;
}
}
 
 
/* Insert a single step breakpoint at the next executed instruction.  */
/* Insert a single step breakpoint at the next executed instruction.  */
 
 
static int
static int
arm_linux_software_single_step (struct frame_info *frame)
arm_linux_software_single_step (struct frame_info *frame)
{
{
  struct gdbarch *gdbarch = get_frame_arch (frame);
  struct gdbarch *gdbarch = get_frame_arch (frame);
  struct address_space *aspace = get_frame_address_space (frame);
  struct address_space *aspace = get_frame_address_space (frame);
  CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
  CORE_ADDR next_pc = arm_get_next_pc (frame, get_frame_pc (frame));
 
 
  /* The Linux kernel offers some user-mode helpers in a high page.  We can
  /* The Linux kernel offers some user-mode helpers in a high page.  We can
     not read this page (as of 2.6.23), and even if we could then we couldn't
     not read this page (as of 2.6.23), and even if we could then we couldn't
     set breakpoints in it, and even if we could then the atomic operations
     set breakpoints in it, and even if we could then the atomic operations
     would fail when interrupted.  They are all called as functions and return
     would fail when interrupted.  They are all called as functions and return
     to the address in LR, so step to there instead.  */
     to the address in LR, so step to there instead.  */
  if (next_pc > 0xffff0000)
  if (next_pc > 0xffff0000)
    next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
    next_pc = get_frame_register_unsigned (frame, ARM_LR_REGNUM);
 
 
  insert_single_step_breakpoint (gdbarch, aspace, next_pc);
  insert_single_step_breakpoint (gdbarch, aspace, next_pc);
 
 
  return 1;
  return 1;
}
}
 
 
/* Support for displaced stepping of Linux SVC instructions.  */
/* Support for displaced stepping of Linux SVC instructions.  */
 
 
static void
static void
arm_linux_cleanup_svc (struct gdbarch *gdbarch ATTRIBUTE_UNUSED,
arm_linux_cleanup_svc (struct gdbarch *gdbarch ATTRIBUTE_UNUSED,
                       struct regcache *regs,
                       struct regcache *regs,
                       struct displaced_step_closure *dsc)
                       struct displaced_step_closure *dsc)
{
{
  CORE_ADDR from = dsc->insn_addr;
  CORE_ADDR from = dsc->insn_addr;
  ULONGEST apparent_pc;
  ULONGEST apparent_pc;
  int within_scratch;
  int within_scratch;
 
 
  regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
  regcache_cooked_read_unsigned (regs, ARM_PC_REGNUM, &apparent_pc);
 
 
  within_scratch = (apparent_pc >= dsc->scratch_base
  within_scratch = (apparent_pc >= dsc->scratch_base
                    && apparent_pc < (dsc->scratch_base
                    && apparent_pc < (dsc->scratch_base
                                      + DISPLACED_MODIFIED_INSNS * 4 + 4));
                                      + DISPLACED_MODIFIED_INSNS * 4 + 4));
 
 
  if (debug_displaced)
  if (debug_displaced)
    {
    {
      fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
      fprintf_unfiltered (gdb_stdlog, "displaced: PC is apparently %.8lx after "
                          "SVC step ", (unsigned long) apparent_pc);
                          "SVC step ", (unsigned long) apparent_pc);
      if (within_scratch)
      if (within_scratch)
        fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
        fprintf_unfiltered (gdb_stdlog, "(within scratch space)\n");
      else
      else
        fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
        fprintf_unfiltered (gdb_stdlog, "(outside scratch space)\n");
    }
    }
 
 
  if (within_scratch)
  if (within_scratch)
    displaced_write_reg (regs, dsc, ARM_PC_REGNUM, from + 4, BRANCH_WRITE_PC);
    displaced_write_reg (regs, dsc, ARM_PC_REGNUM, from + 4, BRANCH_WRITE_PC);
}
}
 
 
static int
static int
arm_linux_copy_svc (struct gdbarch *gdbarch, uint32_t insn, CORE_ADDR to,
arm_linux_copy_svc (struct gdbarch *gdbarch, uint32_t insn, CORE_ADDR to,
                    struct regcache *regs, struct displaced_step_closure *dsc)
                    struct regcache *regs, struct displaced_step_closure *dsc)
{
{
  CORE_ADDR from = dsc->insn_addr;
  CORE_ADDR from = dsc->insn_addr;
  struct frame_info *frame;
  struct frame_info *frame;
  unsigned int svc_number = displaced_read_reg (regs, from, 7);
  unsigned int svc_number = displaced_read_reg (regs, from, 7);
 
 
  if (debug_displaced)
  if (debug_displaced)
    fprintf_unfiltered (gdb_stdlog, "displaced: copying Linux svc insn %.8lx\n",
    fprintf_unfiltered (gdb_stdlog, "displaced: copying Linux svc insn %.8lx\n",
                        (unsigned long) insn);
                        (unsigned long) insn);
 
 
  frame = get_current_frame ();
  frame = get_current_frame ();
 
 
  /* Is this a sigreturn or rt_sigreturn syscall?  Note: these are only useful
  /* Is this a sigreturn or rt_sigreturn syscall?  Note: these are only useful
     for EABI.  */
     for EABI.  */
  if (svc_number == 119 || svc_number == 173)
  if (svc_number == 119 || svc_number == 173)
    {
    {
      if (get_frame_type (frame) == SIGTRAMP_FRAME)
      if (get_frame_type (frame) == SIGTRAMP_FRAME)
        {
        {
          CORE_ADDR return_to;
          CORE_ADDR return_to;
          struct symtab_and_line sal;
          struct symtab_and_line sal;
 
 
          if (debug_displaced)
          if (debug_displaced)
            fprintf_unfiltered (gdb_stdlog, "displaced: found "
            fprintf_unfiltered (gdb_stdlog, "displaced: found "
              "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
              "sigreturn/rt_sigreturn SVC call. PC in frame = %lx\n",
              (unsigned long) get_frame_pc (frame));
              (unsigned long) get_frame_pc (frame));
 
 
          return_to = frame_unwind_caller_pc (frame);
          return_to = frame_unwind_caller_pc (frame);
          if (debug_displaced)
          if (debug_displaced)
            fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
            fprintf_unfiltered (gdb_stdlog, "displaced: unwind pc = %lx. "
              "Setting momentary breakpoint.\n", (unsigned long) return_to);
              "Setting momentary breakpoint.\n", (unsigned long) return_to);
 
 
          gdb_assert (inferior_thread ()->step_resume_breakpoint == NULL);
          gdb_assert (inferior_thread ()->step_resume_breakpoint == NULL);
 
 
          sal = find_pc_line (return_to, 0);
          sal = find_pc_line (return_to, 0);
          sal.pc = return_to;
          sal.pc = return_to;
          sal.section = find_pc_overlay (return_to);
          sal.section = find_pc_overlay (return_to);
          sal.explicit_pc = 1;
          sal.explicit_pc = 1;
 
 
          frame = get_prev_frame (frame);
          frame = get_prev_frame (frame);
 
 
          if (frame)
          if (frame)
            {
            {
              inferior_thread ()->step_resume_breakpoint
              inferior_thread ()->step_resume_breakpoint
                = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
                = set_momentary_breakpoint (gdbarch, sal, get_frame_id (frame),
                                            bp_step_resume);
                                            bp_step_resume);
 
 
              /* We need to make sure we actually insert the momentary
              /* We need to make sure we actually insert the momentary
                 breakpoint set above.  */
                 breakpoint set above.  */
              insert_breakpoints ();
              insert_breakpoints ();
            }
            }
          else if (debug_displaced)
          else if (debug_displaced)
            fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
            fprintf_unfiltered (gdb_stderr, "displaced: couldn't find previous "
                                "frame to set momentary breakpoint for "
                                "frame to set momentary breakpoint for "
                                "sigreturn/rt_sigreturn\n");
                                "sigreturn/rt_sigreturn\n");
        }
        }
      else if (debug_displaced)
      else if (debug_displaced)
        fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
        fprintf_unfiltered (gdb_stdlog, "displaced: sigreturn/rt_sigreturn "
                            "SVC call not in signal trampoline frame\n");
                            "SVC call not in signal trampoline frame\n");
    }
    }
 
 
  /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
  /* Preparation: If we detect sigreturn, set momentary breakpoint at resume
                  location, else nothing.
                  location, else nothing.
     Insn: unmodified svc.
     Insn: unmodified svc.
     Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
     Cleanup: if pc lands in scratch space, pc <- insn_addr + 4
              else leave pc alone.  */
              else leave pc alone.  */
 
 
  dsc->modinsn[0] = insn;
  dsc->modinsn[0] = insn;
 
 
  dsc->cleanup = &arm_linux_cleanup_svc;
  dsc->cleanup = &arm_linux_cleanup_svc;
  /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
  /* Pretend we wrote to the PC, so cleanup doesn't set PC to the next
     instruction.  */
     instruction.  */
  dsc->wrote_to_pc = 1;
  dsc->wrote_to_pc = 1;
 
 
  return 0;
  return 0;
}
}
 
 
 
 
/* The following two functions implement single-stepping over calls to Linux
/* The following two functions implement single-stepping over calls to Linux
   kernel helper routines, which perform e.g. atomic operations on architecture
   kernel helper routines, which perform e.g. atomic operations on architecture
   variants which don't support them natively.
   variants which don't support them natively.
 
 
   When this function is called, the PC will be pointing at the kernel helper
   When this function is called, the PC will be pointing at the kernel helper
   (at an address inaccessible to GDB), and r14 will point to the return
   (at an address inaccessible to GDB), and r14 will point to the return
   address.  Displaced stepping always executes code in the copy area:
   address.  Displaced stepping always executes code in the copy area:
   so, make the copy-area instruction branch back to the kernel helper (the
   so, make the copy-area instruction branch back to the kernel helper (the
   "from" address), and make r14 point to the breakpoint in the copy area.  In
   "from" address), and make r14 point to the breakpoint in the copy area.  In
   that way, we regain control once the kernel helper returns, and can clean
   that way, we regain control once the kernel helper returns, and can clean
   up appropriately (as if we had just returned from the kernel helper as it
   up appropriately (as if we had just returned from the kernel helper as it
   would have been called from the non-displaced location).  */
   would have been called from the non-displaced location).  */
 
 
static void
static void
cleanup_kernel_helper_return (struct gdbarch *gdbarch ATTRIBUTE_UNUSED,
cleanup_kernel_helper_return (struct gdbarch *gdbarch ATTRIBUTE_UNUSED,
                              struct regcache *regs,
                              struct regcache *regs,
                              struct displaced_step_closure *dsc)
                              struct displaced_step_closure *dsc)
{
{
  displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
  displaced_write_reg (regs, dsc, ARM_LR_REGNUM, dsc->tmp[0], CANNOT_WRITE_PC);
  displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
  displaced_write_reg (regs, dsc, ARM_PC_REGNUM, dsc->tmp[0], BRANCH_WRITE_PC);
}
}
 
 
static void
static void
arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
arm_catch_kernel_helper_return (struct gdbarch *gdbarch, CORE_ADDR from,
                                CORE_ADDR to, struct regcache *regs,
                                CORE_ADDR to, struct regcache *regs,
                                struct displaced_step_closure *dsc)
                                struct displaced_step_closure *dsc)
{
{
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 
 
  dsc->numinsns = 1;
  dsc->numinsns = 1;
  dsc->insn_addr = from;
  dsc->insn_addr = from;
  dsc->cleanup = &cleanup_kernel_helper_return;
  dsc->cleanup = &cleanup_kernel_helper_return;
  /* Say we wrote to the PC, else cleanup will set PC to the next
  /* Say we wrote to the PC, else cleanup will set PC to the next
     instruction in the helper, which isn't helpful.  */
     instruction in the helper, which isn't helpful.  */
  dsc->wrote_to_pc = 1;
  dsc->wrote_to_pc = 1;
 
 
  /* Preparation: tmp[0] <- r14
  /* Preparation: tmp[0] <- r14
                  r14 <- <scratch space>+4
                  r14 <- <scratch space>+4
                  *(<scratch space>+8) <- from
                  *(<scratch space>+8) <- from
     Insn: ldr pc, [r14, #4]
     Insn: ldr pc, [r14, #4]
     Cleanup: r14 <- tmp[0], pc <- tmp[0].  */
     Cleanup: r14 <- tmp[0], pc <- tmp[0].  */
 
 
  dsc->tmp[0] = displaced_read_reg (regs, from, ARM_LR_REGNUM);
  dsc->tmp[0] = displaced_read_reg (regs, from, ARM_LR_REGNUM);
  displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
  displaced_write_reg (regs, dsc, ARM_LR_REGNUM, (ULONGEST) to + 4,
                       CANNOT_WRITE_PC);
                       CANNOT_WRITE_PC);
  write_memory_unsigned_integer (to + 8, 4, byte_order, from);
  write_memory_unsigned_integer (to + 8, 4, byte_order, from);
 
 
  dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
  dsc->modinsn[0] = 0xe59ef004;  /* ldr pc, [lr, #4].  */
}
}
 
 
/* Linux-specific displaced step instruction copying function.  Detects when
/* Linux-specific displaced step instruction copying function.  Detects when
   the program has stepped into a Linux kernel helper routine (which must be
   the program has stepped into a Linux kernel helper routine (which must be
   handled as a special case), falling back to arm_displaced_step_copy_insn()
   handled as a special case), falling back to arm_displaced_step_copy_insn()
   if it hasn't.  */
   if it hasn't.  */
 
 
static struct displaced_step_closure *
static struct displaced_step_closure *
arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
                                    CORE_ADDR from, CORE_ADDR to,
                                    CORE_ADDR from, CORE_ADDR to,
                                    struct regcache *regs)
                                    struct regcache *regs)
{
{
  struct displaced_step_closure *dsc
  struct displaced_step_closure *dsc
    = xmalloc (sizeof (struct displaced_step_closure));
    = xmalloc (sizeof (struct displaced_step_closure));
 
 
  /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
  /* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
     stop at the return location.  */
     stop at the return location.  */
  if (from > 0xffff0000)
  if (from > 0xffff0000)
    {
    {
      if (debug_displaced)
      if (debug_displaced)
        fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
        fprintf_unfiltered (gdb_stdlog, "displaced: detected kernel helper "
                            "at %.8lx\n", (unsigned long) from);
                            "at %.8lx\n", (unsigned long) from);
 
 
      arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
      arm_catch_kernel_helper_return (gdbarch, from, to, regs, dsc);
    }
    }
  else
  else
    {
    {
      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
      enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
      uint32_t insn = read_memory_unsigned_integer (from, 4, byte_order);
      uint32_t insn = read_memory_unsigned_integer (from, 4, byte_order);
 
 
      if (debug_displaced)
      if (debug_displaced)
        fprintf_unfiltered (gdb_stdlog, "displaced: stepping insn %.8lx "
        fprintf_unfiltered (gdb_stdlog, "displaced: stepping insn %.8lx "
                            "at %.8lx\n", (unsigned long) insn,
                            "at %.8lx\n", (unsigned long) insn,
                            (unsigned long) from);
                            (unsigned long) from);
 
 
      /* Override the default handling of SVC instructions.  */
      /* Override the default handling of SVC instructions.  */
      dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
      dsc->u.svc.copy_svc_os = arm_linux_copy_svc;
 
 
      arm_process_displaced_insn (gdbarch, insn, from, to, regs, dsc);
      arm_process_displaced_insn (gdbarch, insn, from, to, regs, dsc);
    }
    }
 
 
  arm_displaced_init_closure (gdbarch, from, to, dsc);
  arm_displaced_init_closure (gdbarch, from, to, dsc);
 
 
  return dsc;
  return dsc;
}
}
 
 
static void
static void
arm_linux_init_abi (struct gdbarch_info info,
arm_linux_init_abi (struct gdbarch_info info,
                    struct gdbarch *gdbarch)
                    struct gdbarch *gdbarch)
{
{
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
  struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 
 
  tdep->lowest_pc = 0x8000;
  tdep->lowest_pc = 0x8000;
  if (info.byte_order == BFD_ENDIAN_BIG)
  if (info.byte_order == BFD_ENDIAN_BIG)
    {
    {
      if (tdep->arm_abi == ARM_ABI_AAPCS)
      if (tdep->arm_abi == ARM_ABI_AAPCS)
        tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
        tdep->arm_breakpoint = eabi_linux_arm_be_breakpoint;
      else
      else
        tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
        tdep->arm_breakpoint = arm_linux_arm_be_breakpoint;
      tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
      tdep->thumb_breakpoint = arm_linux_thumb_be_breakpoint;
      tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
      tdep->thumb2_breakpoint = arm_linux_thumb2_be_breakpoint;
    }
    }
  else
  else
    {
    {
      if (tdep->arm_abi == ARM_ABI_AAPCS)
      if (tdep->arm_abi == ARM_ABI_AAPCS)
        tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
        tdep->arm_breakpoint = eabi_linux_arm_le_breakpoint;
      else
      else
        tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
        tdep->arm_breakpoint = arm_linux_arm_le_breakpoint;
      tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
      tdep->thumb_breakpoint = arm_linux_thumb_le_breakpoint;
      tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
      tdep->thumb2_breakpoint = arm_linux_thumb2_le_breakpoint;
    }
    }
  tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
  tdep->arm_breakpoint_size = sizeof (arm_linux_arm_le_breakpoint);
  tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
  tdep->thumb_breakpoint_size = sizeof (arm_linux_thumb_le_breakpoint);
  tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);
  tdep->thumb2_breakpoint_size = sizeof (arm_linux_thumb2_le_breakpoint);
 
 
  if (tdep->fp_model == ARM_FLOAT_AUTO)
  if (tdep->fp_model == ARM_FLOAT_AUTO)
    tdep->fp_model = ARM_FLOAT_FPA;
    tdep->fp_model = ARM_FLOAT_FPA;
 
 
  tdep->jb_pc = ARM_LINUX_JB_PC;
  tdep->jb_pc = ARM_LINUX_JB_PC;
  tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
  tdep->jb_elt_size = ARM_LINUX_JB_ELEMENT_SIZE;
 
 
  set_solib_svr4_fetch_link_map_offsets
  set_solib_svr4_fetch_link_map_offsets
    (gdbarch, svr4_ilp32_fetch_link_map_offsets);
    (gdbarch, svr4_ilp32_fetch_link_map_offsets);
 
 
  /* Single stepping.  */
  /* Single stepping.  */
  set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
  set_gdbarch_software_single_step (gdbarch, arm_linux_software_single_step);
 
 
  /* Shared library handling.  */
  /* Shared library handling.  */
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
  set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target);
  set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
  set_gdbarch_skip_solib_resolver (gdbarch, glibc_skip_solib_resolver);
 
 
  /* Enable TLS support.  */
  /* Enable TLS support.  */
  set_gdbarch_fetch_tls_load_module_address (gdbarch,
  set_gdbarch_fetch_tls_load_module_address (gdbarch,
                                             svr4_fetch_objfile_link_map);
                                             svr4_fetch_objfile_link_map);
 
 
  tramp_frame_prepend_unwinder (gdbarch,
  tramp_frame_prepend_unwinder (gdbarch,
                                &arm_linux_sigreturn_tramp_frame);
                                &arm_linux_sigreturn_tramp_frame);
  tramp_frame_prepend_unwinder (gdbarch,
  tramp_frame_prepend_unwinder (gdbarch,
                                &arm_linux_rt_sigreturn_tramp_frame);
                                &arm_linux_rt_sigreturn_tramp_frame);
  tramp_frame_prepend_unwinder (gdbarch,
  tramp_frame_prepend_unwinder (gdbarch,
                                &arm_eabi_linux_sigreturn_tramp_frame);
                                &arm_eabi_linux_sigreturn_tramp_frame);
  tramp_frame_prepend_unwinder (gdbarch,
  tramp_frame_prepend_unwinder (gdbarch,
                                &arm_eabi_linux_rt_sigreturn_tramp_frame);
                                &arm_eabi_linux_rt_sigreturn_tramp_frame);
  tramp_frame_prepend_unwinder (gdbarch,
  tramp_frame_prepend_unwinder (gdbarch,
                                &arm_linux_restart_syscall_tramp_frame);
                                &arm_linux_restart_syscall_tramp_frame);
 
 
  /* Core file support.  */
  /* Core file support.  */
  set_gdbarch_regset_from_core_section (gdbarch,
  set_gdbarch_regset_from_core_section (gdbarch,
                                        arm_linux_regset_from_core_section);
                                        arm_linux_regset_from_core_section);
 
 
  set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
  set_gdbarch_get_siginfo_type (gdbarch, linux_get_siginfo_type);
 
 
  /* Displaced stepping.  */
  /* Displaced stepping.  */
  set_gdbarch_displaced_step_copy_insn (gdbarch,
  set_gdbarch_displaced_step_copy_insn (gdbarch,
                                        arm_linux_displaced_step_copy_insn);
                                        arm_linux_displaced_step_copy_insn);
  set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
  set_gdbarch_displaced_step_fixup (gdbarch, arm_displaced_step_fixup);
  set_gdbarch_displaced_step_free_closure (gdbarch,
  set_gdbarch_displaced_step_free_closure (gdbarch,
                                           simple_displaced_step_free_closure);
                                           simple_displaced_step_free_closure);
  set_gdbarch_displaced_step_location (gdbarch, displaced_step_at_entry_point);
  set_gdbarch_displaced_step_location (gdbarch, displaced_step_at_entry_point);
}
}
 
 
/* Provide a prototype to silence -Wmissing-prototypes.  */
/* Provide a prototype to silence -Wmissing-prototypes.  */
extern initialize_file_ftype _initialize_arm_linux_tdep;
extern initialize_file_ftype _initialize_arm_linux_tdep;
 
 
void
void
_initialize_arm_linux_tdep (void)
_initialize_arm_linux_tdep (void)
{
{
  gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
  gdbarch_register_osabi (bfd_arch_arm, 0, GDB_OSABI_LINUX,
                          arm_linux_init_abi);
                          arm_linux_init_abi);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.