/* GNU/Linux on ARM native support.
- Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
+ Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2006
+ Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "gdb_string.h"
#include "regcache.h"
+#include "target.h"
+#include "linux-nat.h"
+
+#include "arm-tdep.h"
#include <sys/user.h>
#include <sys/ptrace.h>
#include <sys/utsname.h>
#include <sys/procfs.h>
-#include <asm/ptrace.h>
-
/* Prototypes for supply_gregset etc. */
#include "gregset.h"
+/* Defines ps_err_e, struct ps_prochandle. */
+#include "gdb_proc_service.h"
+
+#ifndef PTRACE_GET_THREAD_AREA
+#define PTRACE_GET_THREAD_AREA 22
+#endif
+
extern int arm_apcs_32;
#define typeNone 0x00
#define typeDouble 0x02
#define typeExtended 0x03
#define FPWORDS 28
-#define CPSR_REGNUM 16
+#define ARM_CPSR_REGNUM 16
typedef union tagFPREG
{
FPA11;
/* The following variables are used to determine the version of the
- underlying Linux operating system. Examples:
+ underlying GNU/Linux operating system. Examples:
- Linux 2.0.35 Linux 2.2.12
+ GNU/Linux 2.0.35 GNU/Linux 2.2.12
os_version = 0x00020023 os_version = 0x0002020c
os_major = 2 os_major = 2
os_minor = 0 os_minor = 2
static unsigned int os_version, os_major, os_minor, os_release;
-/* On Linux, threads are implemented as pseudo-processes, in which
+/* On GNU/Linux, threads are implemented as pseudo-processes, in which
case we may be tracing more than one process at a time. In that
case, inferior_ptid will contain the main process ID and the
- individual thread (process) ID. get_thread_id () is used to
- get the thread id if it's available, and the process id otherwise. */
+ individual thread (process) ID. get_thread_id () is used to get
+ the thread id if it's available, and the process id otherwise. */
int
get_thread_id (ptid_t ptid)
mem[0] = fpa11->fpreg[fn].fSingle;
mem[1] = 0;
mem[2] = 0;
- supply_register (F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
mem[0] = fpa11->fpreg[fn].fDouble[1];
mem[1] = fpa11->fpreg[fn].fDouble[0];
mem[2] = 0;
- supply_register (F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
unsigned int mem[3] =
{0, 0, 0};
- supply_register (F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
mem[0] = fpa11->fpreg[fn].fExtended[0]; /* sign & exponent */
mem[1] = fpa11->fpreg[fn].fExtended[2]; /* ls bits */
mem[2] = fpa11->fpreg[fn].fExtended[1]; /* ms bits */
- supply_register (F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_supply (current_regcache, ARM_F0_REGNUM + fn, (char *) &mem[0]);
}
static void
fetch_nwfpe_register (int regno, FPA11 * fpa11)
{
- int fn = regno - F0_REGNUM;
+ int fn = regno - ARM_F0_REGNUM;
switch (fpa11->fType[fn])
{
}
static void
-store_nwfpe_single (unsigned int fn, FPA11 * fpa11)
+store_nwfpe_single (unsigned int fn, FPA11 *fpa11)
{
unsigned int mem[3];
- read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn,
+ (char *) &mem[0]);
fpa11->fpreg[fn].fSingle = mem[0];
fpa11->fType[fn] = typeSingle;
}
static void
-store_nwfpe_double (unsigned int fn, FPA11 * fpa11)
+store_nwfpe_double (unsigned int fn, FPA11 *fpa11)
{
unsigned int mem[3];
- read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn,
+ (char *) &mem[0]);
fpa11->fpreg[fn].fDouble[1] = mem[0];
fpa11->fpreg[fn].fDouble[0] = mem[1];
fpa11->fType[fn] = typeDouble;
}
void
-store_nwfpe_extended (unsigned int fn, FPA11 * fpa11)
+store_nwfpe_extended (unsigned int fn, FPA11 *fpa11)
{
unsigned int mem[3];
- read_register_gen (F0_REGNUM + fn, (char *) &mem[0]);
+ regcache_raw_collect (current_regcache, ARM_F0_REGNUM + fn,
+ (char *) &mem[0]);
fpa11->fpreg[fn].fExtended[0] = mem[0]; /* sign & exponent */
fpa11->fpreg[fn].fExtended[2] = mem[1]; /* ls bits */
fpa11->fpreg[fn].fExtended[1] = mem[2]; /* ms bits */
void
store_nwfpe_register (int regno, FPA11 * fpa11)
{
- if (register_valid[regno])
+ if (register_cached (regno))
{
- unsigned int fn = regno - F0_REGNUM;
+ unsigned int fn = regno - ARM_F0_REGNUM;
switch (fpa11->fType[fn])
{
case typeSingle:
/* Get the value of a particular register from the floating point
- state of the process and store it into registers[]. */
+ state of the process and store it into regcache. */
static void
fetch_fpregister (int regno)
ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
if (ret < 0)
{
- warning ("Unable to fetch floating point register.");
+ warning (_("Unable to fetch floating point register."));
return;
}
/* Fetch fpsr. */
- if (FPS_REGNUM == regno)
- supply_register (FPS_REGNUM, (char *) &fp.fpsr);
+ if (ARM_FPS_REGNUM == regno)
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Fetch the floating point register. */
- if (regno >= F0_REGNUM && regno <= F7_REGNUM)
+ if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
{
- int fn = regno - F0_REGNUM;
+ int fn = regno - ARM_F0_REGNUM;
switch (fp.fType[fn])
{
}
/* Get the whole floating point state of the process and store it
- into registers[]. */
+ into regcache. */
static void
fetch_fpregs (void)
ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
if (ret < 0)
{
- warning ("Unable to fetch the floating point registers.");
+ warning (_("Unable to fetch the floating point registers."));
return;
}
/* Fetch fpsr. */
- supply_register (FPS_REGNUM, (char *) &fp.fpsr);
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Fetch the floating point registers. */
- for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
+ for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
{
- int fn = regno - F0_REGNUM;
+ int fn = regno - ARM_F0_REGNUM;
switch (fp.fType[fn])
{
}
/* Save a particular register into the floating point state of the
- process using the contents from registers[]. */
+ process using the contents from regcache. */
static void
store_fpregister (int regno)
ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
if (ret < 0)
{
- warning ("Unable to fetch the floating point registers.");
+ warning (_("Unable to fetch the floating point registers."));
return;
}
/* Store fpsr. */
- if (FPS_REGNUM == regno && register_valid[FPS_REGNUM])
- read_register_gen (FPS_REGNUM, (char *) &fp.fpsr);
+ if (ARM_FPS_REGNUM == regno && register_cached (ARM_FPS_REGNUM))
+ regcache_raw_collect (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Store the floating point register. */
- if (regno >= F0_REGNUM && regno <= F7_REGNUM)
+ if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
{
store_nwfpe_register (regno, &fp);
}
ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
if (ret < 0)
{
- warning ("Unable to store floating point register.");
+ warning (_("Unable to store floating point register."));
return;
}
}
/* Save the whole floating point state of the process using
- the contents from registers[]. */
+ the contents from regcache. */
static void
store_fpregs (void)
ret = ptrace (PT_GETFPREGS, tid, 0, &fp);
if (ret < 0)
{
- warning ("Unable to fetch the floating point registers.");
+ warning (_("Unable to fetch the floating point registers."));
return;
}
/* Store fpsr. */
- if (register_valid[FPS_REGNUM])
- read_register_gen (FPS_REGNUM, (char *) &fp.fpsr);
+ if (register_cached (ARM_FPS_REGNUM))
+ regcache_raw_collect (current_regcache, ARM_FPS_REGNUM, (char *) &fp.fpsr);
/* Store the floating point registers. */
- for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
+ for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
{
fetch_nwfpe_register (regno, &fp);
}
ret = ptrace (PTRACE_SETFPREGS, tid, 0, &fp);
if (ret < 0)
{
- warning ("Unable to store floating point registers.");
+ warning (_("Unable to store floating point registers."));
return;
}
}
/* Fetch a general register of the process and store into
- registers[]. */
+ regcache. */
static void
fetch_register (int regno)
{
int ret, tid;
- struct pt_regs regs;
+ elf_gregset_t regs;
/* Get the thread id for the ptrace call. */
tid = GET_THREAD_ID (inferior_ptid);
ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
if (ret < 0)
{
- warning ("Unable to fetch general register.");
+ warning (_("Unable to fetch general register."));
return;
}
- if (regno >= A1_REGNUM && regno < PC_REGNUM)
- supply_register (regno, (char *) ®s.uregs[regno]);
+ if (regno >= ARM_A1_REGNUM && regno < ARM_PC_REGNUM)
+ regcache_raw_supply (current_regcache, regno, (char *) ®s[regno]);
- if (PS_REGNUM == regno)
+ if (ARM_PS_REGNUM == regno)
{
if (arm_apcs_32)
- supply_register (PS_REGNUM, (char *) ®s.uregs[CPSR_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_CPSR_REGNUM]);
else
- supply_register (PS_REGNUM, (char *) ®s.uregs[PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
}
- if (PC_REGNUM == regno)
+ if (ARM_PC_REGNUM == regno)
{
- regs.uregs[PC_REGNUM] = ADDR_BITS_REMOVE (regs.uregs[PC_REGNUM]);
- supply_register (PC_REGNUM, (char *) ®s.uregs[PC_REGNUM]);
+ regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
}
}
/* Fetch all general registers of the process and store into
- registers[]. */
+ regcache. */
static void
fetch_regs (void)
{
int ret, regno, tid;
- struct pt_regs regs;
+ elf_gregset_t regs;
/* Get the thread id for the ptrace call. */
tid = GET_THREAD_ID (inferior_ptid);
ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
if (ret < 0)
{
- warning ("Unable to fetch general registers.");
+ warning (_("Unable to fetch general registers."));
return;
}
- for (regno = A1_REGNUM; regno < PC_REGNUM; regno++)
- supply_register (regno, (char *) ®s.uregs[regno]);
+ for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
+ regcache_raw_supply (current_regcache, regno, (char *) ®s[regno]);
if (arm_apcs_32)
- supply_register (PS_REGNUM, (char *) ®s.uregs[CPSR_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_CPSR_REGNUM]);
else
- supply_register (PS_REGNUM, (char *) ®s.uregs[PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
- regs.uregs[PC_REGNUM] = ADDR_BITS_REMOVE (regs.uregs[PC_REGNUM]);
- supply_register (PC_REGNUM, (char *) ®s.uregs[PC_REGNUM]);
+ regs[ARM_PC_REGNUM] = ADDR_BITS_REMOVE (regs[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
}
/* Store all general registers of the process from the values in
- registers[]. */
+ regcache. */
static void
store_register (int regno)
{
int ret, tid;
- struct pt_regs regs;
+ elf_gregset_t regs;
- if (!register_valid[regno])
+ if (!register_cached (regno))
return;
/* Get the thread id for the ptrace call. */
ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
if (ret < 0)
{
- warning ("Unable to fetch general registers.");
+ warning (_("Unable to fetch general registers."));
return;
}
- if (regno >= A1_REGNUM && regno <= PC_REGNUM)
- read_register_gen (regno, (char *) ®s.uregs[regno]);
+ if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
+ regcache_raw_collect (current_regcache, regno, (char *) ®s[regno]);
+ else if (arm_apcs_32 && regno == ARM_PS_REGNUM)
+ regcache_raw_collect (current_regcache, regno,
+ (char *) ®s[ARM_CPSR_REGNUM]);
+ else if (!arm_apcs_32 && regno == ARM_PS_REGNUM)
+ regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
+ (char *) ®s[ARM_PC_REGNUM]);
ret = ptrace (PTRACE_SETREGS, tid, 0, ®s);
if (ret < 0)
{
- warning ("Unable to store general register.");
+ warning (_("Unable to store general register."));
return;
}
}
store_regs (void)
{
int ret, regno, tid;
- struct pt_regs regs;
+ elf_gregset_t regs;
/* Get the thread id for the ptrace call. */
tid = GET_THREAD_ID (inferior_ptid);
ret = ptrace (PTRACE_GETREGS, tid, 0, ®s);
if (ret < 0)
{
- warning ("Unable to fetch general registers.");
+ warning (_("Unable to fetch general registers."));
return;
}
- for (regno = A1_REGNUM; regno <= PC_REGNUM; regno++)
+ for (regno = ARM_A1_REGNUM; regno <= ARM_PC_REGNUM; regno++)
{
- if (register_valid[regno])
- read_register_gen (regno, (char *) ®s.uregs[regno]);
+ if (register_cached (regno))
+ regcache_raw_collect (current_regcache, regno, (char *) ®s[regno]);
}
+ if (arm_apcs_32 && register_cached (ARM_PS_REGNUM))
+ regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
+ (char *) ®s[ARM_CPSR_REGNUM]);
+
ret = ptrace (PTRACE_SETREGS, tid, 0, ®s);
if (ret < 0)
{
- warning ("Unable to store general registers.");
+ warning (_("Unable to store general registers."));
return;
}
}
regno == -1, otherwise fetch all general registers or all floating
point registers depending upon the value of regno. */
-void
-fetch_inferior_registers (int regno)
+static void
+arm_linux_fetch_inferior_registers (int regno)
{
if (-1 == regno)
{
}
else
{
- if (regno < F0_REGNUM || regno > FPS_REGNUM)
+ if (regno < ARM_F0_REGNUM || regno > ARM_FPS_REGNUM)
fetch_register (regno);
- if (regno >= F0_REGNUM && regno <= FPS_REGNUM)
+ if (regno >= ARM_F0_REGNUM && regno <= ARM_FPS_REGNUM)
fetch_fpregister (regno);
}
}
regno == -1, otherwise store all general registers or all floating
point registers depending upon the value of regno. */
-void
-store_inferior_registers (int regno)
+static void
+arm_linux_store_inferior_registers (int regno)
{
if (-1 == regno)
{
}
else
{
- if ((regno < F0_REGNUM) || (regno > FPS_REGNUM))
+ if ((regno < ARM_F0_REGNUM) || (regno > ARM_FPS_REGNUM))
store_register (regno);
- if ((regno >= F0_REGNUM) && (regno <= FPS_REGNUM))
+ if ((regno >= ARM_F0_REGNUM) && (regno <= ARM_FPS_REGNUM))
store_fpregister (regno);
}
}
if (-1 == regno)
{
int regnum;
- for (regnum = A1_REGNUM; regnum <= PC_REGNUM; regnum++)
- read_register_gen (regnum, (char *) &(*gregsetp)[regnum]);
+ for (regnum = ARM_A1_REGNUM; regnum <= ARM_PC_REGNUM; regnum++)
+ regcache_raw_collect (current_regcache, regnum,
+ (char *) &(*gregsetp)[regnum]);
}
- else if (regno >= A1_REGNUM && regno <= PC_REGNUM)
- read_register_gen (regno, (char *) &(*gregsetp)[regno]);
+ else if (regno >= ARM_A1_REGNUM && regno <= ARM_PC_REGNUM)
+ regcache_raw_collect (current_regcache, regno,
+ (char *) &(*gregsetp)[regno]);
- if (PS_REGNUM == regno || -1 == regno)
+ if (ARM_PS_REGNUM == regno || -1 == regno)
{
if (arm_apcs_32)
- read_register_gen (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]);
+ regcache_raw_collect (current_regcache, ARM_PS_REGNUM,
+ (char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
else
- read_register_gen (PC_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]);
+ regcache_raw_collect (current_regcache, ARM_PC_REGNUM,
+ (char *) &(*gregsetp)[ARM_PC_REGNUM]);
}
}
{
int regno, reg_pc;
- for (regno = A1_REGNUM; regno < PC_REGNUM; regno++)
- supply_register (regno, (char *) &(*gregsetp)[regno]);
+ for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
+ regcache_raw_supply (current_regcache, regno,
+ (char *) &(*gregsetp)[regno]);
if (arm_apcs_32)
- supply_register (PS_REGNUM, (char *) &(*gregsetp)[CPSR_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &(*gregsetp)[ARM_CPSR_REGNUM]);
else
- supply_register (PS_REGNUM, (char *) &(*gregsetp)[PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PS_REGNUM,
+ (char *) &(*gregsetp)[ARM_PC_REGNUM]);
- reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[PC_REGNUM]);
- supply_register (PC_REGNUM, (char *) ®_pc);
+ reg_pc = ADDR_BITS_REMOVE ((CORE_ADDR)(*gregsetp)[ARM_PC_REGNUM]);
+ regcache_raw_supply (current_regcache, ARM_PC_REGNUM, (char *) ®_pc);
}
/* Fill register regno (if it is a floating-point register) in
if (-1 == regno)
{
int regnum;
- for (regnum = F0_REGNUM; regnum <= F7_REGNUM; regnum++)
+ for (regnum = ARM_F0_REGNUM; regnum <= ARM_F7_REGNUM; regnum++)
store_nwfpe_register (regnum, fp);
}
- else if (regno >= F0_REGNUM && regno <= F7_REGNUM)
+ else if (regno >= ARM_F0_REGNUM && regno <= ARM_F7_REGNUM)
{
store_nwfpe_register (regno, fp);
return;
}
/* Store fpsr. */
- if (FPS_REGNUM == regno || -1 == regno)
- read_register_gen (FPS_REGNUM, (char *) &fp->fpsr);
+ if (ARM_FPS_REGNUM == regno || -1 == regno)
+ regcache_raw_collect (current_regcache, ARM_FPS_REGNUM,
+ (char *) &fp->fpsr);
}
/* Fill GDB's register array with the floating-point register values
FPA11 *fp = (FPA11 *) fpregsetp;
/* Fetch fpsr. */
- supply_register (FPS_REGNUM, (char *) &fp->fpsr);
+ regcache_raw_supply (current_regcache, ARM_FPS_REGNUM, (char *) &fp->fpsr);
/* Fetch the floating point registers. */
- for (regno = F0_REGNUM; regno <= F7_REGNUM; regno++)
+ for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
{
fetch_nwfpe_register (regno, fp);
}
return (sizeof (struct user));
}
+/* Fetch the thread-local storage pointer for libthread_db. */
+
+ps_err_e
+ps_get_thread_area (const struct ps_prochandle *ph,
+ lwpid_t lwpid, int idx, void **base)
+{
+ if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
+ return PS_ERR;
+
+ /* IDX is the bias from the thread pointer to the beginning of the
+ thread descriptor. It has to be subtracted due to implementation
+ quirks in libthread_db. */
+ *base = (void *) ((char *)*base - idx);
+
+ return PS_OK;
+}
+
static unsigned int
get_linux_version (unsigned int *vmajor,
unsigned int *vminor,
if (-1 == uname (&info))
{
- warning ("Unable to determine Linux version.");
+ warning (_("Unable to determine GNU/Linux version."));
return -1;
}
return ((*vmajor << 16) | (*vminor << 8) | *vrelease);
}
+void _initialize_arm_linux_nat (void);
+
void
_initialize_arm_linux_nat (void)
{
+ struct target_ops *t;
+
os_version = get_linux_version (&os_major, &os_minor, &os_release);
+
+ /* Fill in the generic GNU/Linux methods. */
+ t = linux_target ();
+
+ /* Add our register access methods. */
+ t->to_fetch_registers = arm_linux_fetch_inferior_registers;
+ t->to_store_registers = arm_linux_store_inferior_registers;
+
+ /* Register the target. */
+ linux_nat_add_target (t);
}
projects / deliverable / binutils-gdb.git / blobdiff