#include "defs.h"
#include "inferior.h"
#include "gdbcore.h"
#include "regcache.h"
#include "gdb_assert.h"
#include "gdb_string.h"
#include <sys/ptrace.h>
#include <sys/user.h>
#include <sys/procfs.h>
#ifdef HAVE_SYS_REG_H
#include <sys/reg.h>
#endif
#ifndef ORIG_EAX
#define ORIG_EAX -1
#endif
#ifdef HAVE_SYS_DEBUGREG_H
#include <sys/debugreg.h>
#endif
#ifndef DR_FIRSTADDR
#define DR_FIRSTADDR 0
#endif
#ifndef DR_LASTADDR
#define DR_LASTADDR 3
#endif
#ifndef DR_STATUS
#define DR_STATUS 6
#endif
#ifndef DR_CONTROL
#define DR_CONTROL 7
#endif
#include "gregset.h"
#include "i387-tdep.h"
#include "i386-tdep.h"
#include "i386-linux-tdep.h"
static void dummy_sse_values (void);
static int regmap[] =
{
EAX, ECX, EDX, EBX,
UESP, EBP, ESI, EDI,
EIP, EFL, CS, SS,
DS, ES, FS, GS,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1, -1, -1, -1,
-1,
ORIG_EAX
};
#define GETREGS_SUPPLIES(regno) \
((0 <= (regno) && (regno) <= 15) || (regno) == I386_LINUX_ORIG_EAX_REGNUM)
#define GETFPREGS_SUPPLIES(regno) \
(FP0_REGNUM <= (regno) && (regno) <= LAST_FPU_CTRL_REGNUM)
#define GETFPXREGS_SUPPLIES(regno) \
(FP0_REGNUM <= (regno) && (regno) <= MXCSR_REGNUM)
int have_ptrace_getregs =
#ifdef HAVE_PTRACE_GETREGS
1
#else
0
#endif
;
int have_ptrace_getfpxregs =
#ifdef HAVE_PTRACE_GETFPXREGS
1
#else
0
#endif
;
CORE_ADDR
register_u_addr (CORE_ADDR blockend, int regnum)
{
return (blockend + 4 * regmap[regnum]);
}
int
kernel_u_size (void)
{
return (sizeof (struct user));
}
static void
fetch_register (int regno)
{
int tid;
int val;
gdb_assert (!have_ptrace_getregs);
if (cannot_fetch_register (regno))
{
supply_register (regno, NULL);
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
errno = 0;
val = ptrace (PTRACE_PEEKUSER, tid, register_addr (regno, 0), 0);
if (errno != 0)
error ("Couldn't read register %s (#%d): %s.", REGISTER_NAME (regno),
regno, safe_strerror (errno));
supply_register (regno, &val);
}
static void
store_register (int regno)
{
int tid;
int val;
gdb_assert (!have_ptrace_getregs);
if (cannot_store_register (regno))
return;
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
errno = 0;
regcache_collect (regno, &val);
ptrace (PTRACE_POKEUSER, tid, register_addr (regno, 0), val);
if (errno != 0)
error ("Couldn't read register %s (#%d): %s.", REGISTER_NAME (regno),
regno, safe_strerror (errno));
}
void
supply_gregset (elf_gregset_t *gregsetp)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
supply_register (i, (char *) (regp + regmap[i]));
if (I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
supply_register (I386_LINUX_ORIG_EAX_REGNUM, (char *) (regp + ORIG_EAX));
}
void
fill_gregset (elf_gregset_t *gregsetp, int regno)
{
elf_greg_t *regp = (elf_greg_t *) gregsetp;
int i;
for (i = 0; i < I386_NUM_GREGS; i++)
if (regno == -1 || regno == i)
regcache_collect (i, regp + regmap[i]);
if ((regno == -1 || regno == I386_LINUX_ORIG_EAX_REGNUM)
&& I386_LINUX_ORIG_EAX_REGNUM < NUM_REGS)
regcache_collect (I386_LINUX_ORIG_EAX_REGNUM, regp + ORIG_EAX);
}
#ifdef HAVE_PTRACE_GETREGS
static void
fetch_regs (int tid)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
{
if (errno == EIO)
{
have_ptrace_getregs = 0;
return;
}
perror_with_name ("Couldn't get registers");
}
supply_gregset (®s);
}
static void
store_regs (int tid, int regno)
{
elf_gregset_t regs;
if (ptrace (PTRACE_GETREGS, tid, 0, (int) ®s) < 0)
perror_with_name ("Couldn't get registers");
fill_gregset (®s, regno);
if (ptrace (PTRACE_SETREGS, tid, 0, (int) ®s) < 0)
perror_with_name ("Couldn't write registers");
}
#else
static void fetch_regs (int tid) {}
static void store_regs (int tid, int regno) {}
#endif
void
supply_fpregset (elf_fpregset_t *fpregsetp)
{
i387_supply_fsave ((char *) fpregsetp);
dummy_sse_values ();
}
void
fill_fpregset (elf_fpregset_t *fpregsetp, int regno)
{
i387_fill_fsave ((char *) fpregsetp, regno);
}
#ifdef HAVE_PTRACE_GETREGS
static void
fetch_fpregs (int tid)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name ("Couldn't get floating point status");
supply_fpregset (&fpregs);
}
static void
store_fpregs (int tid, int regno)
{
elf_fpregset_t fpregs;
if (ptrace (PTRACE_GETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name ("Couldn't get floating point status");
fill_fpregset (&fpregs, regno);
if (ptrace (PTRACE_SETFPREGS, tid, 0, (int) &fpregs) < 0)
perror_with_name ("Couldn't write floating point status");
}
#else
static void fetch_fpregs (int tid) {}
static void store_fpregs (int tid, int regno) {}
#endif
#ifdef HAVE_PTRACE_GETFPXREGS
void
supply_fpxregset (elf_fpxregset_t *fpxregsetp)
{
i387_supply_fxsave ((char *) fpxregsetp);
}
void
fill_fpxregset (elf_fpxregset_t *fpxregsetp, int regno)
{
i387_fill_fxsave ((char *) fpxregsetp, regno);
}
static int
fetch_fpxregs (int tid)
{
elf_fpxregset_t fpxregs;
if (! have_ptrace_getfpxregs)
return 0;
if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
{
if (errno == EIO)
{
have_ptrace_getfpxregs = 0;
return 0;
}
perror_with_name ("Couldn't read floating-point and SSE registers");
}
supply_fpxregset (&fpxregs);
return 1;
}
static int
store_fpxregs (int tid, int regno)
{
elf_fpxregset_t fpxregs;
if (! have_ptrace_getfpxregs)
return 0;
if (ptrace (PTRACE_GETFPXREGS, tid, 0, &fpxregs) == -1)
{
if (errno == EIO)
{
have_ptrace_getfpxregs = 0;
return 0;
}
perror_with_name ("Couldn't read floating-point and SSE registers");
}
fill_fpxregset (&fpxregs, regno);
if (ptrace (PTRACE_SETFPXREGS, tid, 0, &fpxregs) == -1)
perror_with_name ("Couldn't write floating-point and SSE registers");
return 1;
}
static void
dummy_sse_values (void)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
static long dummy[4] = { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff };
static long mxcsr = 0x1f80;
int reg;
for (reg = 0; reg < tdep->num_xmm_regs; reg++)
supply_register (XMM0_REGNUM + reg, (char *) dummy);
if (tdep->num_xmm_regs > 0)
supply_register (MXCSR_REGNUM, (char *) &mxcsr);
}
#else
static int fetch_fpxregs (int tid) { return 0; }
static int store_fpxregs (int tid, int regno) { return 0; }
static void dummy_sse_values (void) {}
#endif
int
cannot_fetch_register (int regno)
{
gdb_assert (regno >= 0 && regno < NUM_REGS);
return (!have_ptrace_getregs && regmap[regno] == -1);
}
int
cannot_store_register (int regno)
{
gdb_assert (regno >= 0 && regno < NUM_REGS);
return (!have_ptrace_getregs && regmap[regno] == -1);
}
void
fetch_inferior_registers (int regno)
{
int tid;
if (!have_ptrace_getregs)
{
int i;
for (i = 0; i < NUM_REGS; i++)
if (regno == -1 || regno == i)
fetch_register (i);
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
if (regno == -1)
{
fetch_regs (tid);
if (!have_ptrace_getregs)
{
fetch_inferior_registers (regno);
return;
}
if (fetch_fpxregs (tid))
return;
fetch_fpregs (tid);
return;
}
if (GETREGS_SUPPLIES (regno))
{
fetch_regs (tid);
return;
}
if (GETFPXREGS_SUPPLIES (regno))
{
if (fetch_fpxregs (tid))
return;
fetch_fpregs (tid);
return;
}
internal_error (__FILE__, __LINE__,
"Got request for bad register number %d.", regno);
}
void
store_inferior_registers (int regno)
{
int tid;
if (!have_ptrace_getregs)
{
int i;
for (i = 0; i < NUM_REGS; i++)
if (regno == -1 || regno == i)
store_register (i);
return;
}
if ((tid = TIDGET (inferior_ptid)) == 0)
tid = PIDGET (inferior_ptid);
if (regno == -1)
{
store_regs (tid, regno);
if (store_fpxregs (tid, regno))
return;
store_fpregs (tid, regno);
return;
}
if (GETREGS_SUPPLIES (regno))
{
store_regs (tid, regno);
return;
}
if (GETFPXREGS_SUPPLIES (regno))
{
if (store_fpxregs (tid, regno))
return;
store_fpregs (tid, regno);
return;
}
internal_error (__FILE__, __LINE__,
"Got request to store bad register number %d.", regno);
}
static unsigned long
i386_linux_dr_get (int regnum)
{
int tid;
unsigned long value;
tid = PIDGET (inferior_ptid);
errno = 0;
value = ptrace (PTRACE_PEEKUSER, tid,
offsetof (struct user, u_debugreg[regnum]), 0);
if (errno != 0)
#if 0
perror_with_name ("Couldn't read debug register");
#else
return 0;
#endif
return value;
}
static void
i386_linux_dr_set (int regnum, unsigned long value)
{
int tid;
tid = PIDGET (inferior_ptid);
errno = 0;
ptrace (PTRACE_POKEUSER, tid,
offsetof (struct user, u_debugreg[regnum]), value);
if (errno != 0)
perror_with_name ("Couldn't write debug register");
}
void
i386_linux_dr_set_control (unsigned long control)
{
i386_linux_dr_set (DR_CONTROL, control);
}
void
i386_linux_dr_set_addr (int regnum, CORE_ADDR addr)
{
gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
i386_linux_dr_set (DR_FIRSTADDR + regnum, addr);
}
void
i386_linux_dr_reset_addr (int regnum)
{
gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
i386_linux_dr_set (DR_FIRSTADDR + regnum, 0L);
}
unsigned long
i386_linux_dr_get_status (void)
{
return i386_linux_dr_get (DR_STATUS);
}
static void
fetch_core_registers (char *core_reg_sect, unsigned core_reg_size,
int which, CORE_ADDR reg_addr)
{
elf_gregset_t gregset;
elf_fpregset_t fpregset;
switch (which)
{
case 0:
if (core_reg_size != sizeof (gregset))
warning ("Wrong size gregset in core file.");
else
{
memcpy (&gregset, core_reg_sect, sizeof (gregset));
supply_gregset (&gregset);
}
break;
case 2:
if (core_reg_size != sizeof (fpregset))
warning ("Wrong size fpregset in core file.");
else
{
memcpy (&fpregset, core_reg_sect, sizeof (fpregset));
supply_fpregset (&fpregset);
}
break;
#ifdef HAVE_PTRACE_GETFPXREGS
{
elf_fpxregset_t fpxregset;
case 3:
if (core_reg_size != sizeof (fpxregset))
warning ("Wrong size fpxregset in core file.");
else
{
memcpy (&fpxregset, core_reg_sect, sizeof (fpxregset));
supply_fpxregset (&fpxregset);
}
break;
}
#endif
default:
break;
}
}
static const unsigned char linux_syscall[] = { 0xcd, 0x80 };
#define LINUX_SYSCALL_LEN (sizeof linux_syscall)
#define LINUX_SYSCALL_REGNUM 0
#ifndef SYS_sigreturn
#define SYS_sigreturn 0x77
#endif
#ifndef SYS_rt_sigreturn
#define SYS_rt_sigreturn 0xad
#endif
#define LINUX_SIGCONTEXT_EFLAGS_OFFSET (64)
void
child_resume (ptid_t ptid, int step, enum target_signal signal)
{
int pid = PIDGET (ptid);
int request = PTRACE_CONT;
if (pid == -1)
pid = PIDGET (inferior_ptid);
if (step)
{
CORE_ADDR pc = read_pc_pid (pid_to_ptid (pid));
unsigned char buf[LINUX_SYSCALL_LEN];
request = PTRACE_SINGLESTEP;
if (read_memory_nobpt (pc, (char *) buf, LINUX_SYSCALL_LEN) == 0
&& memcmp (buf, linux_syscall, LINUX_SYSCALL_LEN) == 0)
{
int syscall = read_register_pid (LINUX_SYSCALL_REGNUM,
pid_to_ptid (pid));
if (syscall == SYS_sigreturn || syscall == SYS_rt_sigreturn)
{
CORE_ADDR sp = read_register (SP_REGNUM);
CORE_ADDR addr = sp;
unsigned long int eflags;
if (syscall == SYS_rt_sigreturn)
addr = read_memory_integer (sp + 8, 4) + 20;
addr += LINUX_SIGCONTEXT_EFLAGS_OFFSET;
read_memory (addr, (char *) &eflags, 4);
eflags |= 0x0100;
write_memory (addr, (char *) &eflags, 4);
}
}
}
if (ptrace (request, pid, 0, target_signal_to_host (signal)) == -1)
perror_with_name ("ptrace");
}
static struct core_fns linux_elf_core_fns =
{
bfd_target_elf_flavour,
default_check_format,
default_core_sniffer,
fetch_core_registers,
NULL
};
void
_initialize_i386_linux_nat (void)
{
add_core_fns (&linux_elf_core_fns);
}